home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / gawk-3.000 / gawk-3 / gawk-3.0.0 / awktab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-31  |  113.6 KB  |  3,800 lines
  1.  
  2. /*  A Bison parser, made from ./awk.y with Bison version GNU Bison version 1.22
  3.   */
  4.  
  5. #define YYBISON 1  /* Identify Bison output.  */
  6.  
  7. #define    FUNC_CALL    258
  8. #define    NAME    259
  9. #define    REGEXP    260
  10. #define    ERROR    261
  11. #define    YNUMBER    262
  12. #define    YSTRING    263
  13. #define    RELOP    264
  14. #define    APPEND_OP    265
  15. #define    ASSIGNOP    266
  16. #define    MATCHOP    267
  17. #define    NEWLINE    268
  18. #define    CONCAT_OP    269
  19. #define    LEX_BEGIN    270
  20. #define    LEX_END    271
  21. #define    LEX_IF    272
  22. #define    LEX_ELSE    273
  23. #define    LEX_RETURN    274
  24. #define    LEX_DELETE    275
  25. #define    LEX_WHILE    276
  26. #define    LEX_DO    277
  27. #define    LEX_FOR    278
  28. #define    LEX_BREAK    279
  29. #define    LEX_CONTINUE    280
  30. #define    LEX_PRINT    281
  31. #define    LEX_PRINTF    282
  32. #define    LEX_NEXT    283
  33. #define    LEX_EXIT    284
  34. #define    LEX_FUNCTION    285
  35. #define    LEX_GETLINE    286
  36. #define    LEX_NEXTFILE    287
  37. #define    LEX_IN    288
  38. #define    LEX_AND    289
  39. #define    LEX_OR    290
  40. #define    INCREMENT    291
  41. #define    DECREMENT    292
  42. #define    LEX_BUILTIN    293
  43. #define    LEX_LENGTH    294
  44. #define    UNARY    295
  45.  
  46. #line 26 "./awk.y"
  47.  
  48. #ifdef DEBUG
  49. #define YYDEBUG 12
  50. #endif
  51.  
  52. #include "awk.h"
  53.  
  54. #define CAN_FREE    TRUE
  55. #define DONT_FREE    FALSE
  56.  
  57. #if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
  58. static void yyerror(const char *m, ...) ;
  59. #else
  60. static void yyerror(); /* va_alist */
  61. #endif
  62. static char *get_src_buf P((void));
  63. static int yylex P((void));
  64. static NODE *node_common P((NODETYPE op));
  65. static NODE *snode P((NODE *subn, NODETYPE op, int sindex));
  66. static NODE *mkrangenode P((NODE *cpair));
  67. static NODE *make_for_loop P((NODE *init, NODE *cond, NODE *incr));
  68. static NODE *append_right P((NODE *list, NODE *new));
  69. static void func_install P((NODE *params, NODE *def));
  70. static void pop_var P((NODE *np, int freeit));
  71. static void pop_params P((NODE *params));
  72. static NODE *make_param P((char *name));
  73. static NODE *mk_rexp P((NODE *exp));
  74. static int dup_parms P((NODE *func));
  75. static void param_sanity P((NODE *arglist));
  76. static int isnoeffect P((NODETYPE));
  77.  
  78. enum defref { FUNC_DEFINE, FUNC_USE };
  79. static void func_use P((char *name, enum defref how));
  80. static void check_funcs P((void));
  81.  
  82. static int want_assign;        /* lexical scanning kludge */
  83. static int want_regexp;        /* lexical scanning kludge */
  84. static int can_return;        /* lexical scanning kludge */
  85. static int io_allowed = TRUE;    /* lexical scanning kludge */
  86. static char *lexptr;        /* pointer to next char during parsing */
  87. static char *lexend;
  88. static char *lexptr_begin;    /* keep track of where we were for error msgs */
  89. static char *lexeme;        /* beginning of lexeme for debugging */
  90. static char *thisline = NULL;
  91. #define YYDEBUG_LEXER_TEXT (lexeme)
  92. static int param_counter;
  93. static char *tokstart = NULL;
  94. static char *tok = NULL;
  95. static char *tokend;
  96.  
  97. #define HASHSIZE    1021    /* this constant only used here */
  98. NODE *variables[HASHSIZE];
  99.  
  100. extern char *source;
  101. extern int sourceline;
  102. extern struct src *srcfiles;
  103. extern int numfiles;
  104. extern int errcount;
  105. extern NODE *begin_block;
  106. extern NODE *end_block;
  107.  
  108. #line 88 "./awk.y"
  109. typedef union {
  110.     long lval;
  111.     AWKNUM fval;
  112.     NODE *nodeval;
  113.     NODETYPE nodetypeval;
  114.     char *sval;
  115.     NODE *(*ptrval)();
  116. } YYSTYPE;
  117.  
  118. #ifndef YYLTYPE
  119. typedef
  120.   struct yyltype
  121.     {
  122.       int timestamp;
  123.       int first_line;
  124.       int first_column;
  125.       int last_line;
  126.       int last_column;
  127.       char *text;
  128.    }
  129.   yyltype;
  130.  
  131. #define YYLTYPE yyltype
  132. #endif
  133.  
  134. #include <stdio.h>
  135.  
  136. #ifndef __cplusplus
  137. #ifndef __STDC__
  138. #define const
  139. #endif
  140. #endif
  141.  
  142.  
  143.  
  144. #define    YYFINAL        312
  145. #define    YYFLAG        -32768
  146. #define    YYNTBASE    62
  147.  
  148. #define YYTRANSLATE(x) ((unsigned)(x) <= 295 ? yytranslate[x] : 107)
  149.  
  150. static const char yytranslate[] = {     0,
  151.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  152.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  153.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  154.      2,     2,    51,     2,     2,    54,    50,     2,     2,    55,
  155.     56,    48,    46,    42,    47,     2,    49,     2,     2,     2,
  156.      2,     2,     2,     2,     2,     2,     2,    41,    61,    43,
  157.      2,    44,    40,     2,     2,     2,     2,     2,     2,     2,
  158.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  159.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  160.     57,     2,    58,    53,     2,     2,     2,     2,     2,     2,
  161.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  162.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  163.      2,     2,    59,    45,    60,     2,     2,     2,     2,     2,
  164.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  165.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  166.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  167.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  168.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  169.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  170.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  171.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  172.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  173.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  174.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  175.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  176.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  177.      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
  178.     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  179.     26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
  180.     36,    37,    38,    39,    52
  181. };
  182.  
  183. #if YYDEBUG != 0
  184. static const short yyprhs[] = {     0,
  185.      0,     4,     6,     9,    11,    14,    15,    16,    20,    21,
  186.     25,    28,    31,    34,    36,    39,    42,    44,    46,    48,
  187.     50,    52,    53,    61,    66,    71,    73,    77,    78,    83,
  188.     89,    94,    96,    99,   101,   104,   106,   109,   112,   115,
  189.    119,   121,   128,   137,   146,   157,   167,   170,   173,   180,
  190.    185,   189,   192,   196,   197,   202,   209,   213,   216,   218,
  191.    220,   227,   237,   239,   242,   243,   245,   246,   249,   250,
  192.    253,   256,   259,   260,   262,   264,   268,   270,   273,   277,
  193.    278,   280,   281,   283,   285,   289,   291,   294,   298,   302,
  194.    303,   305,   307,   311,   313,   316,   320,   324,   325,   330,
  195.    336,   341,   345,   349,   353,   357,   359,   362,   366,   370,
  196.    374,   378,   384,   386,   389,   390,   395,   399,   403,   407,
  197.    409,   412,   416,   420,   424,   430,   432,   435,   437,   441,
  198.    445,   449,   453,   457,   461,   464,   467,   470,   474,   479,
  199.    484,   486,   491,   493,   496,   499,   501,   503,   506,   509,
  200.    510,   512,   514,   519,   522,   525,   528,   530,   531,   533,
  201.    535
  202. };
  203.  
  204. static const short yyrhs[] = {    83,
  205.     63,    83,     0,    64,     0,    63,    64,     0,     1,     0,
  206.     63,     1,     0,     0,     0,    15,    65,    75,     0,     0,
  207.     16,    66,    75,     0,    15,    77,     0,    16,    77,     0,
  208.     72,    75,     0,    75,     0,    72,    77,     0,    69,    71,
  209.      0,     4,     0,     3,     0,    68,     0,    38,     0,    39,
  210.      0,     0,    30,    70,    67,    55,    86,   103,    83,     0,
  211.    101,    76,   102,   104,     0,   101,   102,   104,    83,     0,
  212.     93,     0,    93,    42,    93,     0,     0,    49,    74,     5,
  213.     49,     0,   101,    76,   102,   104,    83,     0,   101,   102,
  214.    104,    83,     0,    78,     0,    76,    78,     0,     1,     0,
  215.     76,     1,     0,    82,     0,   105,    83,     0,   105,    83,
  216.      0,   101,   102,     0,   101,    76,   102,     0,    81,     0,
  217.     21,    55,    93,   103,    83,    78,     0,    22,    83,    78,
  218.     21,    55,    93,   103,    83,     0,    23,    55,     4,    33,
  219.      4,   103,    83,    78,     0,    23,    55,    88,   105,    93,
  220.    105,    88,   103,    83,    78,     0,    23,    55,    88,   105,
  221.    105,    88,   103,    83,    78,     0,    24,    77,     0,    25,
  222.     77,     0,    80,    55,    92,   103,    85,    77,     0,    80,
  223.     89,    85,    77,     0,    28,    88,    77,     0,    32,    77,
  224.      0,    29,    88,    77,     0,     0,    19,    79,    88,    77,
  225.      0,    20,     4,    57,    92,    58,    77,     0,    20,     4,
  226.     77,     0,    93,    77,     0,    26,     0,    27,     0,    17,
  227.     55,    93,   103,    83,    78,     0,    17,    55,    93,   103,
  228.     83,    78,    18,    83,    78,     0,    13,     0,    82,    13,
  229.      0,     0,    82,     0,     0,    43,    97,     0,     0,    44,
  230.     93,     0,    10,    93,     0,    45,    93,     0,     0,    87,
  231.      0,     4,     0,    87,   106,     4,     0,     1,     0,    87,
  232.      1,     0,    87,   106,     1,     0,     0,    93,     0,     0,
  233.     90,     0,    95,     0,    90,   106,    95,     0,     1,     0,
  234.     90,     1,     0,    90,     1,    95,     0,    90,   106,     1,
  235.      0,     0,    92,     0,    93,     0,    92,   106,    93,     0,
  236.      1,     0,    92,     1,     0,    92,     1,    93,     0,    92,
  237.    106,     1,     0,     0,   100,    11,    94,    93,     0,    55,
  238.     92,   103,    33,     4,     0,    93,    45,    31,    99,     0,
  239.     31,    99,    84,     0,    93,    34,    93,     0,    93,    35,
  240.     93,     0,    93,    12,    93,     0,    73,     0,    51,    73,
  241.      0,    93,    33,     4,     0,    93,     9,    93,     0,    93,
  242.     43,    93,     0,    93,    44,    93,     0,    93,    40,    93,
  243.     41,    93,     0,    97,     0,    93,    97,     0,     0,   100,
  244.     11,    96,    95,     0,    95,    34,    95,     0,    95,    35,
  245.     95,     0,    31,    99,    84,     0,    73,     0,    51,    73,
  246.      0,    95,    12,    95,     0,    95,    33,     4,     0,    95,
  247.      9,    95,     0,    95,    40,    95,    41,    95,     0,    97,
  248.      0,    95,    97,     0,    98,     0,    97,    53,    97,     0,
  249.     97,    48,    97,     0,    97,    49,    97,     0,    97,    50,
  250.     97,     0,    97,    46,    97,     0,    97,    47,    97,     0,
  251.    100,    36,     0,   100,    37,     0,    51,    97,     0,    55,
  252.     93,   103,     0,    38,    55,    91,   103,     0,    39,    55,
  253.     91,   103,     0,    39,     0,     3,    55,    91,   103,     0,
  254.    100,     0,    36,   100,     0,    37,   100,     0,     7,     0,
  255.      8,     0,    47,    97,     0,    46,    97,     0,     0,   100,
  256.      0,     4,     0,     4,    57,    92,    58,     0,    54,    98,
  257.      0,    59,    83,     0,    60,    83,     0,    56,     0,     0,
  258.    105,     0,    61,     0,    42,    83,     0
  259. };
  260.  
  261. #endif
  262.  
  263. #if YYDEBUG != 0
  264. static const short yyrline[] = { 0,
  265.    149,   157,   165,   181,   182,   183,   187,   189,   203,   205,
  266.    219,   225,   231,   233,   235,   248,   257,   259,   261,   271,
  267.    272,   276,   280,   291,   296,   305,   307,   316,   318,   336,
  268.    338,   343,   349,   357,   359,   364,   365,   369,   371,   373,
  269.    375,   377,   379,   381,   387,   391,   396,   399,   402,   404,
  270.    424,   463,   482,   484,   489,   491,   493,   507,   512,   514,
  271.    519,   524,   531,   533,   537,   538,   542,   544,   549,   551,
  272.    553,   555,   560,   562,   567,   569,   571,   573,   575,   581,
  273.    583,   588,   590,   595,   597,   603,   605,   607,   609,   614,
  274.    616,   621,   623,   629,   631,   633,   635,   640,   643,   648,
  275.    650,   655,   661,   663,   665,   671,   681,   689,   691,   697,
  276.    699,   701,   703,   705,   710,   713,   714,   716,   718,   724,
  277.    726,   728,   730,   732,   734,   736,   738,   743,   745,   747,
  278.    749,   751,   753,   755,   757,   759,   764,   766,   768,   771,
  279.    773,   781,   788,   789,   791,   793,   795,   798,   806,   817,
  280.    819,   824,   826,   834,   839,   843,   847,   851,   852,   856,
  281.    859
  282. };
  283.  
  284. static const char * const yytname[] = {   "$","error","$illegal.","FUNC_CALL",
  285. "NAME","REGEXP","ERROR","YNUMBER","YSTRING","RELOP","APPEND_OP","ASSIGNOP","MATCHOP",
  286. "NEWLINE","CONCAT_OP","LEX_BEGIN","LEX_END","LEX_IF","LEX_ELSE","LEX_RETURN",
  287. "LEX_DELETE","LEX_WHILE","LEX_DO","LEX_FOR","LEX_BREAK","LEX_CONTINUE","LEX_PRINT",
  288. "LEX_PRINTF","LEX_NEXT","LEX_EXIT","LEX_FUNCTION","LEX_GETLINE","LEX_NEXTFILE",
  289. "LEX_IN","LEX_AND","LEX_OR","INCREMENT","DECREMENT","LEX_BUILTIN","LEX_LENGTH",
  290. "'?'","':'","','","'<'","'>'","'|'","'+'","'-'","'*'","'/'","'%'","'!'","UNARY",
  291. "'^'","'$'","'('","')'","'['","']'","'{'","'}'","';'","start","program","rule",
  292. "@1","@2","func_name","lex_builtin","function_prologue","@3","function_body",
  293. "pattern","regexp","@4","action","statements","statement_term","statement","@5",
  294. "print","if_statement","nls","opt_nls","input_redir","output_redir","opt_param_list",
  295. "param_list","opt_exp","opt_rexpression_list","rexpression_list","opt_expression_list",
  296. "expression_list","exp","@6","rexp","@7","simp_exp","non_post_simp_exp","opt_variable",
  297. "variable","l_brace","r_brace","r_paren","opt_semi","semi","comma",""
  298. };
  299. #endif
  300.  
  301. static const short yyr1[] = {     0,
  302.     62,    63,    63,    63,    63,    63,    65,    64,    66,    64,
  303.     64,    64,    64,    64,    64,    64,    67,    67,    67,    68,
  304.     68,    70,    69,    71,    71,    72,    72,    74,    73,    75,
  305.     75,    76,    76,    76,    76,    77,    77,    78,    78,    78,
  306.     78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
  307.     78,    78,    78,    79,    78,    78,    78,    78,    80,    80,
  308.     81,    81,    82,    82,    83,    83,    84,    84,    85,    85,
  309.     85,    85,    86,    86,    87,    87,    87,    87,    87,    88,
  310.     88,    89,    89,    90,    90,    90,    90,    90,    90,    91,
  311.     91,    92,    92,    92,    92,    92,    92,    94,    93,    93,
  312.     93,    93,    93,    93,    93,    93,    93,    93,    93,    93,
  313.     93,    93,    93,    93,    96,    95,    95,    95,    95,    95,
  314.     95,    95,    95,    95,    95,    95,    95,    97,    97,    97,
  315.     97,    97,    97,    97,    97,    97,    98,    98,    98,    98,
  316.     98,    98,    98,    98,    98,    98,    98,    98,    98,    99,
  317.     99,   100,   100,   100,   101,   102,   103,   104,   104,   105,
  318.    106
  319. };
  320.  
  321. static const short yyr2[] = {     0,
  322.      3,     1,     2,     1,     2,     0,     0,     3,     0,     3,
  323.      2,     2,     2,     1,     2,     2,     1,     1,     1,     1,
  324.      1,     0,     7,     4,     4,     1,     3,     0,     4,     5,
  325.      4,     1,     2,     1,     2,     1,     2,     2,     2,     3,
  326.      1,     6,     8,     8,    10,     9,     2,     2,     6,     4,
  327.      3,     2,     3,     0,     4,     6,     3,     2,     1,     1,
  328.      6,     9,     1,     2,     0,     1,     0,     2,     0,     2,
  329.      2,     2,     0,     1,     1,     3,     1,     2,     3,     0,
  330.      1,     0,     1,     1,     3,     1,     2,     3,     3,     0,
  331.      1,     1,     3,     1,     2,     3,     3,     0,     4,     5,
  332.      4,     3,     3,     3,     3,     1,     2,     3,     3,     3,
  333.      3,     5,     1,     2,     0,     4,     3,     3,     3,     1,
  334.      2,     3,     3,     3,     5,     1,     2,     1,     3,     3,
  335.      3,     3,     3,     3,     2,     2,     2,     3,     4,     4,
  336.      1,     4,     1,     2,     2,     1,     1,     2,     2,     0,
  337.      1,     1,     4,     2,     2,     2,     1,     0,     1,     1,
  338.      2
  339. };
  340.  
  341. static const short yydefact[] = {    65,
  342.     63,    66,     0,    64,     4,     0,   152,   146,   147,     7,
  343.      9,    22,   150,     0,     0,     0,   141,     0,     0,    28,
  344.      0,     0,     0,    65,     0,     2,     0,     0,   106,    14,
  345.     26,   113,   128,   143,     0,     0,     0,   160,     0,    11,
  346.     36,    65,     0,    12,     0,    67,   151,   144,   145,     0,
  347.      0,     0,     0,   149,   143,   148,     0,   107,   137,   154,
  348.    143,    94,     0,    92,   155,     5,     3,     1,    16,     0,
  349.     13,    15,     0,     0,     0,     0,     0,     0,     0,     0,
  350.      0,     0,   114,     0,     0,     0,     0,     0,     0,    98,
  351.    135,   136,    34,     0,    54,     0,     0,    65,     0,     0,
  352.      0,    59,    60,    80,    80,     0,    65,     0,    32,     0,
  353.     41,     0,     0,   158,    65,     0,     0,    92,     0,     8,
  354.     37,    10,    18,    17,    20,    21,     0,    19,     0,   102,
  355.      0,     0,     0,     0,    95,    65,   157,     0,     0,   138,
  356.      0,   158,   109,   105,   108,   103,   104,     0,    27,   110,
  357.    111,   150,   133,   134,   130,   131,   132,   129,     0,     0,
  358.     80,     0,     0,     0,    80,    47,    48,     0,    81,     0,
  359.     52,   156,    35,    33,   158,    86,   150,     0,     0,   120,
  360.     69,     0,    84,   126,   143,    58,     0,    39,    65,   159,
  361.     38,   142,   153,     0,    68,   139,   140,    29,    96,   161,
  362.      0,    97,    93,   158,    65,     0,   101,    99,     0,     0,
  363.      0,    57,     0,     0,   152,     0,    51,    53,    65,    67,
  364.    121,     0,     0,     0,     0,     0,    87,     0,     0,     0,
  365.      0,     0,     0,     0,   127,   115,    40,    31,    77,    75,
  366.      0,     0,   100,    24,    25,   112,    65,    55,     0,    65,
  367.      0,     0,     0,    30,   119,    69,    71,    70,    72,    50,
  368.     88,    89,    85,   124,   122,   123,   117,   118,     0,     0,
  369.     65,    78,     0,     0,     0,     0,     0,     0,     0,    80,
  370.      0,     0,   116,    23,    79,    76,    61,    56,    42,     0,
  371.     65,    80,     0,    49,   125,    65,    65,     0,     0,    65,
  372.      0,    43,    44,    65,     0,    62,     0,    46,    45,     0,
  373.      0,     0
  374. };
  375.  
  376. static const short yydefgoto[] = {   310,
  377.     25,    26,    39,    43,   127,   128,    27,    45,    69,    28,
  378.     29,    57,    30,   108,    40,   109,   161,   110,   111,     2,
  379.      3,   130,   226,   241,   242,   168,   181,   182,   116,   117,
  380.    112,   159,   183,   270,    32,    33,    46,    34,   113,   114,
  381.    140,   189,    42,   139
  382. };
  383.  
  384. static const short yypact[] = {    -6,
  385. -32768,     0,   875,-32768,-32768,   -40,   -38,-32768,-32768,    -7,
  386.     -7,-32768,    10,    10,    10,   -31,   -26,  1735,  1735,-32768,
  387.   1715,  1735,  1131,    -6,   932,-32768,   -24,    72,-32768,-32768,
  388.   1304,   205,-32768,     5,   709,  1110,  1131,-32768,   -24,-32768,
  389.      0,    -6,   -24,-32768,    85,     3,-32768,-32768,-32768,  1110,
  390.   1110,  1735,  1620,     8,   106,     8,    81,-32768,     8,-32768,
  391. -32768,-32768,    37,  1250,-32768,-32768,-32768,-32768,-32768,   709,
  392. -32768,-32768,  1620,  1620,    90,  1620,  1620,  1620,  1620,  1620,
  393.   1620,    65,   205,  1735,  1735,  1735,  1735,  1735,  1735,-32768,
  394. -32768,-32768,-32768,    50,-32768,   111,    70,    -6,    93,    -7,
  395.     -7,-32768,-32768,  1620,  1620,    -7,    -6,   758,-32768,   819,
  396. -32768,  1040,   709,   100,    -6,    99,    55,  1402,     9,-32768,
  397. -32768,-32768,-32768,-32768,-32768,-32768,   109,-32768,  1735,-32768,
  398.     99,    99,  1250,   119,  1620,    -6,-32768,   133,  1180,-32768,
  399.    758,   100,  1327,   794,-32768,  1515,  1451,  1353,  1402,  1327,
  400.   1327,    10,   125,   125,     8,     8,     8,     8,  1620,  1620,
  401.   1620,    42,  1620,   981,  1657,-32768,-32768,    -7,  1402,    -7,
  402. -32768,-32768,-32768,-32768,   100,-32768,    10,  1715,  1131,-32768,
  403.     96,    39,  1538,   205,   117,-32768,   758,-32768,    -6,-32768,
  404. -32768,-32768,-32768,     7,   205,-32768,-32768,-32768,  1402,-32768,
  405.    166,-32768,  1402,   100,    -6,  1620,-32768,  1402,  1250,    -7,
  406.   1131,-32768,  1250,   151,   -12,   100,-32768,-32768,    -6,     3,
  407. -32768,    37,  1620,  1620,  1620,    -7,  1678,  1201,  1678,  1678,
  408.    181,  1678,  1678,  1678,   205,-32768,-32768,-32768,-32768,-32768,
  409.     99,    56,-32768,-32768,-32768,  1402,    -6,-32768,    11,    -6,
  410.    131,   183,  1061,-32768,-32768,    96,  1402,  1402,  1402,-32768,
  411.   1538,-32768,  1538,   635,    83,-32768,  1599,  1579,  1474,  1678,
  412.     -6,-32768,   103,   981,    -7,   981,  1620,    99,   623,  1620,
  413.     -7,  1678,  1538,-32768,-32768,-32768,   170,-32768,-32768,  1250,
  414.     -6,  1620,    99,-32768,  1538,    -6,    -6,   981,    99,    -6,
  415.    981,-32768,-32768,    -6,   981,-32768,   981,-32768,-32768,   190,
  416.    191,-32768
  417. };
  418.  
  419. static const short yypgoto[] = {-32768,
  420. -32768,   167,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  421.    211,-32768,   107,   -53,   315,  -105,-32768,-32768,-32768,   199,
  422.     97,   -22,   -62,-32768,-32768,  -103,-32768,-32768,    94,   -14,
  423.     -3,-32768,  -202,-32768,   318,   177,  -134,    95,   124,   -69,
  424.    407,  -138,   420,  -177
  425. };
  426.  
  427.  
  428. #define    YYLAST        1790
  429.  
  430.  
  431. static const short yytable[] = {    31,
  432.    142,   170,   174,   205,   228,     1,     1,   239,    63,   135,
  433.    240,   135,     4,     7,    36,    90,   141,   207,    37,    64,
  434.    252,    31,   119,    50,   261,   263,   264,   265,    51,   267,
  435.    268,   269,   118,   118,    24,   174,   219,   135,   175,   227,
  436.     91,    92,   220,   188,    37,   129,   118,   118,   -83,   133,
  437.    136,   -83,   136,    38,     1,   135,   272,   210,   214,   187,
  438.     89,   216,   -73,    22,   273,   244,   193,   283,   275,   143,
  439.    144,   204,   146,   147,   148,   149,   150,   151,   136,   295,
  440.    136,   174,   -83,   -83,     1,   134,     7,   123,   124,     8,
  441.      9,   229,   137,   145,-32768,   152,   136,   136,   211,   -83,
  442.    169,   169,    38,   285,   160,   223,   286,    47,    48,    49,
  443.    -91,   -74,    55,    55,   162,    55,    61,   237,    14,    15,
  444.     65,    68,   125,   126,   163,    55,    35,   236,    18,    19,
  445.     24,   199,    38,    52,    71,   203,    22,    53,   121,   224,
  446.    225,    91,    92,   131,   132,   120,    55,   165,    35,   122,
  447.     70,    35,    91,    92,   137,   208,   209,   169,    55,   213,
  448.     38,   169,    35,   194,   222,   201,    35,   198,   287,   243,
  449.    289,   251,    86,    87,    88,    64,   293,    89,    55,    55,
  450.     55,    55,    55,    55,   266,   277,   278,   296,   299,   311,
  451.    312,    67,   303,   281,   164,   306,   249,   255,    60,   308,
  452.      0,   309,   246,   172,   185,     0,    55,   118,    41,    41,
  453.      0,   191,    55,     0,     0,     0,     0,     0,     0,   257,
  454.    258,   259,     0,    55,     0,     0,    41,    55,     0,     0,
  455.      0,    58,   200,     0,     0,     0,     0,    55,    55,     0,
  456.     55,    55,    55,    55,    55,    55,    47,     0,     0,   279,
  457.     84,    85,    86,    87,    88,     0,     0,    89,     0,     0,
  458.      0,     0,     0,    55,     0,     0,     0,     0,     0,     0,
  459.      0,    47,    55,   290,     0,     0,   169,    55,     0,     0,
  460.      0,     0,     0,     0,     0,   238,     0,     0,   169,     0,
  461.      0,     0,     0,    55,     0,     0,     0,    55,    41,    41,
  462.      0,   245,    55,    55,    41,     0,     0,    55,     0,     0,
  463.     41,     0,     0,     0,     0,   254,     0,     0,     0,     0,
  464.    180,   185,   185,   185,   185,    44,   185,   185,   185,     0,
  465.      0,     0,     0,     0,     0,    54,    56,     0,    59,     0,
  466.     55,     0,    72,   274,     0,     0,   276,     0,    83,     0,
  467.      0,    55,    55,    55,     0,    55,     0,    55,    55,    55,
  468.     41,    55,    55,    55,   185,     0,    41,   284,    41,    59,
  469.      0,     0,     0,    55,     0,     0,   185,    55,     0,     0,
  470.      0,    83,     0,     0,    55,     0,     0,   298,   221,    55,
  471.      0,     0,   301,   302,     0,     0,   305,     0,     0,     0,
  472.    307,   153,   154,   155,   156,   157,   158,     0,    41,     0,
  473.      0,     0,     0,     0,   166,   167,     0,     0,     0,     0,
  474.    171,     0,     0,     0,    41,     0,   186,   184,     0,    83,
  475.      0,     0,     0,     0,     0,    83,     0,   180,   180,   180,
  476.    180,     0,   180,   180,   180,     0,   195,     0,     0,     0,
  477.     83,     0,     0,     0,   115,     0,     0,     0,     0,     0,
  478.     83,    83,     0,    83,    83,    83,    83,    83,    83,   138,
  479.      0,     0,     0,    41,     0,     0,   212,     0,     0,    41,
  480.    180,     0,   217,     0,   218,     0,    83,     0,     0,   115,
  481.      0,     0,   180,     0,     0,    59,     0,     0,     0,     0,
  482.    235,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  483.      0,     0,     0,     0,     0,     0,    83,     0,     0,     0,
  484.     83,     0,   192,     0,   248,    83,    83,   115,     0,     0,
  485.     83,     0,   115,   190,     0,     0,     0,   196,   197,     0,
  486.    260,     0,     0,     0,   184,   184,   184,   184,     0,   184,
  487.    184,   184,     0,     0,     0,     0,     0,     0,     0,     0,
  488.    115,   190,     0,    83,     0,     0,     0,     0,     0,     0,
  489.      0,     0,     0,     0,    83,    83,    83,     0,   235,     0,
  490.    235,   235,   235,   115,   235,   235,   235,   184,     0,   288,
  491.      0,     0,     0,     0,   190,   294,    83,     0,     0,   184,
  492.    235,     0,     0,     0,     0,     0,   115,    83,     0,     0,
  493.      0,     0,   235,     0,     0,   247,     0,     0,     0,   250,
  494.      0,     0,     0,   190,     0,     6,     7,     0,   256,     8,
  495.      9,    73,     0,     0,    74,   253,     0,     0,     7,     0,
  496.      0,     8,     9,-32768,     0,     0,     0,   271,     0,     0,
  497.      0,     0,     0,     0,     0,    75,    76,    77,    14,    15,
  498.     16,    17,    78,     0,     0,    80,    81,    82,    18,    19,
  499.     14,    15,   280,    52,     0,     0,    22,    53,     0,     0,
  500.     18,    19,     0,    38,   291,    52,     0,     0,    22,    53,
  501.      0,     0,     0,   115,     0,   115,   297,     0,   292,   300,
  502.      0,     0,     0,     0,     0,   304,     0,     0,     0,    93,
  503.      0,     6,     7,     0,     0,     8,     9,   115,     0,     0,
  504.    115,     0,     0,     0,   115,    94,   115,    95,    96,    97,
  505.     98,    99,   100,   101,   102,   103,   104,   105,     0,    13,
  506.    106,     0,     0,     0,    14,    15,    16,    17,     0,     0,
  507.      0,     0,     0,     0,    18,    19,     0,    20,   173,    21,
  508.      6,     7,    22,    23,     8,     9,     0,    24,   107,    38,
  509.      0,     0,     0,     0,    94,     0,    95,    96,    97,    98,
  510.     99,   100,   101,   102,   103,   104,   105,     0,    13,   106,
  511.      0,     0,     0,    14,    15,    16,    17,     7,     0,     0,
  512.      8,     9,    73,    18,    19,-32768,    20,     0,    21,     0,
  513.      0,    22,    23,     0,     0,     0,    24,   107,    38,   176,
  514.      0,     6,     7,     0,     0,     8,     9,     0,   -82,    14,
  515.     15,   -82,     0,     0,     0,     0,    80,    81,    82,    18,
  516.     19,     0,     0,     0,    52,     0,     0,    22,    53,   177,
  517.      0,     0,     0,     0,    14,    15,    16,    17,     0,     0,
  518.      0,     0,   -82,   -82,    18,    19,     0,    20,     0,   178,
  519.      0,     0,    22,   179,    -6,     5,     0,     6,     7,   -82,
  520.      0,     8,     9,     0,     0,     0,     0,    -6,     0,    10,
  521.     11,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  522.      0,     0,     0,     0,    12,    13,     0,     0,     0,     0,
  523.     14,    15,    16,    17,     0,     0,     0,     0,     0,     0,
  524.     18,    19,     0,    20,     0,    21,     0,     0,    22,    23,
  525.      0,   -65,    66,    24,     6,     7,     0,     0,     8,     9,
  526.      0,     0,     0,     0,     1,     0,    10,    11,     0,     0,
  527.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  528.      0,    12,    13,     0,     0,     0,     0,    14,    15,    16,
  529.     17,     0,     0,     0,     0,     0,     0,    18,    19,     0,
  530.     20,     0,    21,     6,     7,    22,    23,     8,     9,     0,
  531.     24,     0,     0,     0,     0,     0,     0,    94,     0,    95,
  532.     96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
  533.      0,    13,   106,     0,     0,     0,    14,    15,    16,    17,
  534.      0,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  535.      0,    21,     0,     0,    22,    23,     0,     0,     0,    24,
  536.      0,    38,     6,     7,     0,     0,     8,     9,    73,     0,
  537.      0,    74,     1,     0,     0,     0,     0,     0,     0,     0,
  538.      0,     0,     0,     6,     7,     0,     0,     8,     9,     0,
  539.      0,     0,    75,    76,    77,    14,    15,    16,    17,    78,
  540.      0,     0,    80,    81,    82,    18,    19,     0,     0,     0,
  541.     52,    13,     0,    22,    53,     0,    14,    15,    16,    17,
  542.     38,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  543.     62,    21,     6,     7,    22,    23,     8,     9,     0,     0,
  544.      0,    38,     0,     0,     0,     0,     0,     0,     0,     0,
  545.      0,    62,     0,     6,     7,     0,     0,     8,     9,     0,
  546.     13,     0,     0,     0,     0,    14,    15,    16,    17,     0,
  547.      0,     0,     0,     0,     0,    18,    19,     0,    20,     0,
  548.     21,    13,     0,    22,    23,   -90,    14,    15,    16,    17,
  549.      0,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  550.    202,    21,     6,     7,    22,    23,     8,     9,     0,     0,
  551.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  552.      0,   262,     0,     6,     7,     0,     0,     8,     9,     0,
  553.     13,     0,     0,     0,     0,    14,    15,    16,    17,     0,
  554.      0,     0,     0,     0,     0,    18,    19,     0,    20,     0,
  555.     21,   177,     0,    22,    23,     0,    14,    15,    16,    17,
  556.      0,     0,     0,     0,     0,     0,    18,    19,     0,    20,
  557.      0,   178,     6,     7,    22,    53,     8,     9,    73,     0,
  558.      0,    74,     0,     0,     0,     0,     0,     0,     0,     0,
  559.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  560.      0,     0,    75,    76,    77,    14,    15,    16,    17,    78,
  561.      0,     0,    80,    81,    82,    18,    19,     0,     0,     0,
  562.     52,     0,     0,    22,    53,   137,     6,     7,     0,     0,
  563.      8,     9,    73,     0,     0,    74,     0,     0,     0,     0,
  564.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  565.      7,     0,     0,     8,     9,-32768,    75,    76,    77,    14,
  566.     15,    16,    17,    78,     0,    79,    80,    81,    82,    18,
  567.     19,     0,     0,     0,    52,     6,     7,    22,    53,     8,
  568.      9,    73,    14,    15,    74,     0,     0,     0,     0,-32768,
  569. -32768,-32768,    18,    19,     0,     0,     0,    52,     0,     0,
  570.     22,    53,     0,     0,     0,    75,    76,    77,    14,    15,
  571.     16,    17,    78,   206,     0,    80,    81,    82,    18,    19,
  572.      0,     0,     0,    52,     6,     7,    22,    53,     8,     9,
  573.     73,     0,     0,    74,     0,     0,     0,     0,     0,     0,
  574.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  575.      0,     0,     0,     0,    75,    76,    77,    14,    15,    16,
  576.     17,    78,     0,     0,    80,    81,    82,    18,    19,     0,
  577.      0,     0,    52,     6,     7,    22,    53,     8,     9,    73,
  578.      0,     0,    74,     0,     0,     0,     0,     0,     0,     0,
  579.      0,     0,     0,     0,     0,     0,     6,     7,     0,     0,
  580.      8,     9,   229,    75,    76,   230,    14,    15,    16,    17,
  581.      0,     0,     0,    80,    81,    82,    18,    19,     0,     0,
  582.      0,    52,     0,     0,    22,    53,   231,   232,   233,    14,
  583.     15,    16,    17,   234,   282,     0,     0,     6,     7,    18,
  584.     19,     8,     9,    73,    52,     0,    74,    22,    53,     0,
  585.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  586.      6,     7,     0,     0,     8,     9,   229,    75,     0,   230,
  587.     14,    15,    16,    17,     0,     0,     0,    80,    81,    82,
  588.     18,    19,     0,     0,     0,    52,     0,     0,    22,    53,
  589.    231,   232,   233,    14,    15,    16,    17,   234,     0,     0,
  590.      0,     6,     7,    18,    19,     8,     9,   229,    52,     0,
  591.    230,    22,    53,     0,     0,     0,     0,     0,     0,     0,
  592.      0,     6,     7,     0,     0,     8,     9,   229,     0,     0,
  593.    230,   231,   232,     0,    14,    15,    16,    17,     0,     0,
  594.      0,     0,     6,     7,    18,    19,     8,     9,     0,    52,
  595.      0,   231,    22,    53,    14,    15,    16,    17,     0,     0,
  596.      0,     0,     0,     0,    18,    19,     0,     0,     0,    52,
  597.     13,     0,    22,    53,     0,    14,    15,    16,    17,     6,
  598.    215,     0,     0,     8,     9,    18,    19,     0,    20,     0,
  599.     21,     0,     0,    22,    23,     0,     0,     0,     0,     0,
  600.      6,     7,     0,     0,     8,     9,     0,    13,     0,     0,
  601.      0,     0,    14,    15,    16,    17,     0,     0,     0,     0,
  602.      0,     0,    18,    19,     0,    20,     0,    21,   177,     0,
  603.     22,    23,     0,    14,    15,    16,    17,     6,     7,     0,
  604.      0,     8,     9,    18,    19,     0,    20,     0,   178,     0,
  605.      0,    22,    53,     0,     0,     0,     0,     6,     7,     0,
  606.      0,     8,     9,     0,     0,     0,     0,     0,     0,     0,
  607.     14,    15,    16,    17,     0,     0,     0,     0,     0,     0,
  608.     18,    19,     0,    20,     0,    52,     0,     0,    22,    53,
  609.     14,    15,    16,    17,     0,     0,     0,     0,     0,     0,
  610.     18,    19,     0,     0,     0,    52,     0,     0,    22,    53
  611. };
  612.  
  613. static const short yycheck[] = {     3,
  614.     70,   105,   108,   142,   182,    13,    13,     1,    23,     1,
  615.      4,     1,    13,     4,    55,    11,    70,   152,    57,    23,
  616.     33,    25,    37,    55,   227,   228,   229,   230,    55,   232,
  617.    233,   234,    36,    37,    59,   141,   175,     1,   108,     1,
  618.     36,    37,   177,   113,    57,    43,    50,    51,    10,    53,
  619.     42,    13,    42,    61,    13,     1,     1,   161,   164,   113,
  620.     53,   165,    56,    54,   242,   204,    58,   270,    58,    73,
  621.     74,   141,    76,    77,    78,    79,    80,    81,    42,   282,
  622.     42,   187,    44,    45,    13,     5,     4,     3,     4,     7,
  623.      8,     9,    56,     4,    12,    31,    42,    42,    57,    61,
  624.    104,   105,    61,     1,    55,    10,     4,    13,    14,    15,
  625.     56,    56,    18,    19,     4,    21,    22,   187,    36,    37,
  626.     24,    25,    38,    39,    55,    31,     3,    11,    46,    47,
  627.     59,   135,    61,    51,    28,   139,    54,    55,    42,    44,
  628.     45,    36,    37,    50,    51,    39,    52,    55,    25,    43,
  629.     27,    28,    36,    37,    56,   159,   160,   161,    64,   163,
  630.     61,   165,    39,    55,   179,    33,    43,    49,   274,     4,
  631.    276,    21,    48,    49,    50,   179,   280,    53,    84,    85,
  632.     86,    87,    88,    89,     4,    55,     4,    18,   292,     0,
  633.      0,    25,   298,   256,    98,   301,   211,   220,    22,   305,
  634.     -1,   307,   206,   107,   110,    -1,   112,   211,    10,    11,
  635.     -1,   115,   118,    -1,    -1,    -1,    -1,    -1,    -1,   223,
  636.    224,   225,    -1,   129,    -1,    -1,    28,   133,    -1,    -1,
  637.     -1,    21,   136,    -1,    -1,    -1,    -1,   143,   144,    -1,
  638.    146,   147,   148,   149,   150,   151,   152,    -1,    -1,   253,
  639.     46,    47,    48,    49,    50,    -1,    -1,    53,    -1,    -1,
  640.     -1,    -1,    -1,   169,    -1,    -1,    -1,    -1,    -1,    -1,
  641.     -1,   177,   178,   277,    -1,    -1,   280,   183,    -1,    -1,
  642.     -1,    -1,    -1,    -1,    -1,   189,    -1,    -1,   292,    -1,
  643.     -1,    -1,    -1,   199,    -1,    -1,    -1,   203,   100,   101,
  644.     -1,   205,   208,   209,   106,    -1,    -1,   213,    -1,    -1,
  645.    112,    -1,    -1,    -1,    -1,   219,    -1,    -1,    -1,    -1,
  646.    110,   227,   228,   229,   230,    11,   232,   233,   234,    -1,
  647.     -1,    -1,    -1,    -1,    -1,    18,    19,    -1,    21,    -1,
  648.    246,    -1,    28,   247,    -1,    -1,   250,    -1,    31,    -1,
  649.     -1,   257,   258,   259,    -1,   261,    -1,   263,   264,   265,
  650.    162,   267,   268,   269,   270,    -1,   168,   271,   170,    52,
  651.     -1,    -1,    -1,   279,    -1,    -1,   282,   283,    -1,    -1,
  652.     -1,    64,    -1,    -1,   290,    -1,    -1,   291,   178,   295,
  653.     -1,    -1,   296,   297,    -1,    -1,   300,    -1,    -1,    -1,
  654.    304,    84,    85,    86,    87,    88,    89,    -1,   210,    -1,
  655.     -1,    -1,    -1,    -1,   100,   101,    -1,    -1,    -1,    -1,
  656.    106,    -1,    -1,    -1,   226,    -1,   112,   110,    -1,   112,
  657.     -1,    -1,    -1,    -1,    -1,   118,    -1,   227,   228,   229,
  658.    230,    -1,   232,   233,   234,    -1,   129,    -1,    -1,    -1,
  659.    133,    -1,    -1,    -1,    35,    -1,    -1,    -1,    -1,    -1,
  660.    143,   144,    -1,   146,   147,   148,   149,   150,   151,    63,
  661.     -1,    -1,    -1,   275,    -1,    -1,   162,    -1,    -1,   281,
  662.    270,    -1,   168,    -1,   170,    -1,   169,    -1,    -1,    70,
  663.     -1,    -1,   282,    -1,    -1,   178,    -1,    -1,    -1,    -1,
  664.    183,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  665.     -1,    -1,    -1,    -1,    -1,    -1,   199,    -1,    -1,    -1,
  666.    203,    -1,   116,    -1,   210,   208,   209,   108,    -1,    -1,
  667.    213,    -1,   113,   114,    -1,    -1,    -1,   131,   132,    -1,
  668.    226,    -1,    -1,    -1,   227,   228,   229,   230,    -1,   232,
  669.    233,   234,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  670.    141,   142,    -1,   246,    -1,    -1,    -1,    -1,    -1,    -1,
  671.     -1,    -1,    -1,    -1,   257,   258,   259,    -1,   261,    -1,
  672.    263,   264,   265,   164,   267,   268,   269,   270,    -1,   275,
  673.     -1,    -1,    -1,    -1,   175,   281,   279,    -1,    -1,   282,
  674.    283,    -1,    -1,    -1,    -1,    -1,   187,   290,    -1,    -1,
  675.     -1,    -1,   295,    -1,    -1,   209,    -1,    -1,    -1,   213,
  676.     -1,    -1,    -1,   204,    -1,     3,     4,    -1,   222,     7,
  677.      8,     9,    -1,    -1,    12,   216,    -1,    -1,     4,    -1,
  678.     -1,     7,     8,     9,    -1,    -1,    -1,   241,    -1,    -1,
  679.     -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
  680.     38,    39,    40,    -1,    -1,    43,    44,    45,    46,    47,
  681.     36,    37,   253,    51,    -1,    -1,    54,    55,    -1,    -1,
  682.     46,    47,    -1,    61,   278,    51,    -1,    -1,    54,    55,
  683.     -1,    -1,    -1,   274,    -1,   276,   290,    -1,   279,   293,
  684.     -1,    -1,    -1,    -1,    -1,   299,    -1,    -1,    -1,     1,
  685.     -1,     3,     4,    -1,    -1,     7,     8,   298,    -1,    -1,
  686.    301,    -1,    -1,    -1,   305,    17,   307,    19,    20,    21,
  687.     22,    23,    24,    25,    26,    27,    28,    29,    -1,    31,
  688.     32,    -1,    -1,    -1,    36,    37,    38,    39,    -1,    -1,
  689.     -1,    -1,    -1,    -1,    46,    47,    -1,    49,     1,    51,
  690.      3,     4,    54,    55,     7,     8,    -1,    59,    60,    61,
  691.     -1,    -1,    -1,    -1,    17,    -1,    19,    20,    21,    22,
  692.     23,    24,    25,    26,    27,    28,    29,    -1,    31,    32,
  693.     -1,    -1,    -1,    36,    37,    38,    39,     4,    -1,    -1,
  694.      7,     8,     9,    46,    47,    12,    49,    -1,    51,    -1,
  695.     -1,    54,    55,    -1,    -1,    -1,    59,    60,    61,     1,
  696.     -1,     3,     4,    -1,    -1,     7,     8,    -1,    10,    36,
  697.     37,    13,    -1,    -1,    -1,    -1,    43,    44,    45,    46,
  698.     47,    -1,    -1,    -1,    51,    -1,    -1,    54,    55,    31,
  699.     -1,    -1,    -1,    -1,    36,    37,    38,    39,    -1,    -1,
  700.     -1,    -1,    44,    45,    46,    47,    -1,    49,    -1,    51,
  701.     -1,    -1,    54,    55,     0,     1,    -1,     3,     4,    61,
  702.     -1,     7,     8,    -1,    -1,    -1,    -1,    13,    -1,    15,
  703.     16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  704.     -1,    -1,    -1,    -1,    30,    31,    -1,    -1,    -1,    -1,
  705.     36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,
  706.     46,    47,    -1,    49,    -1,    51,    -1,    -1,    54,    55,
  707.     -1,     0,     1,    59,     3,     4,    -1,    -1,     7,     8,
  708.     -1,    -1,    -1,    -1,    13,    -1,    15,    16,    -1,    -1,
  709.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  710.     -1,    30,    31,    -1,    -1,    -1,    -1,    36,    37,    38,
  711.     39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,
  712.     49,    -1,    51,     3,     4,    54,    55,     7,     8,    -1,
  713.     59,    -1,    -1,    -1,    -1,    -1,    -1,    17,    -1,    19,
  714.     20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
  715.     -1,    31,    32,    -1,    -1,    -1,    36,    37,    38,    39,
  716.     -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  717.     -1,    51,    -1,    -1,    54,    55,    -1,    -1,    -1,    59,
  718.     -1,    61,     3,     4,    -1,    -1,     7,     8,     9,    -1,
  719.     -1,    12,    13,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  720.     -1,    -1,    -1,     3,     4,    -1,    -1,     7,     8,    -1,
  721.     -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
  722.     -1,    -1,    43,    44,    45,    46,    47,    -1,    -1,    -1,
  723.     51,    31,    -1,    54,    55,    -1,    36,    37,    38,    39,
  724.     61,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  725.      1,    51,     3,     4,    54,    55,     7,     8,    -1,    -1,
  726.     -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  727.     -1,     1,    -1,     3,     4,    -1,    -1,     7,     8,    -1,
  728.     31,    -1,    -1,    -1,    -1,    36,    37,    38,    39,    -1,
  729.     -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,    -1,
  730.     51,    31,    -1,    54,    55,    56,    36,    37,    38,    39,
  731.     -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  732.      1,    51,     3,     4,    54,    55,     7,     8,    -1,    -1,
  733.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  734.     -1,     1,    -1,     3,     4,    -1,    -1,     7,     8,    -1,
  735.     31,    -1,    -1,    -1,    -1,    36,    37,    38,    39,    -1,
  736.     -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,    -1,
  737.     51,    31,    -1,    54,    55,    -1,    36,    37,    38,    39,
  738.     -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,    49,
  739.     -1,    51,     3,     4,    54,    55,     7,     8,     9,    -1,
  740.     -1,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  741.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  742.     -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
  743.     -1,    -1,    43,    44,    45,    46,    47,    -1,    -1,    -1,
  744.     51,    -1,    -1,    54,    55,    56,     3,     4,    -1,    -1,
  745.      7,     8,     9,    -1,    -1,    12,    -1,    -1,    -1,    -1,
  746.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  747.      4,    -1,    -1,     7,     8,     9,    33,    34,    35,    36,
  748.     37,    38,    39,    40,    -1,    42,    43,    44,    45,    46,
  749.     47,    -1,    -1,    -1,    51,     3,     4,    54,    55,     7,
  750.      8,     9,    36,    37,    12,    -1,    -1,    -1,    -1,    43,
  751.     44,    45,    46,    47,    -1,    -1,    -1,    51,    -1,    -1,
  752.     54,    55,    -1,    -1,    -1,    33,    34,    35,    36,    37,
  753.     38,    39,    40,    41,    -1,    43,    44,    45,    46,    47,
  754.     -1,    -1,    -1,    51,     3,     4,    54,    55,     7,     8,
  755.      9,    -1,    -1,    12,    -1,    -1,    -1,    -1,    -1,    -1,
  756.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  757.     -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,    38,
  758.     39,    40,    -1,    -1,    43,    44,    45,    46,    47,    -1,
  759.     -1,    -1,    51,     3,     4,    54,    55,     7,     8,     9,
  760.     -1,    -1,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  761.     -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,    -1,
  762.      7,     8,     9,    33,    34,    12,    36,    37,    38,    39,
  763.     -1,    -1,    -1,    43,    44,    45,    46,    47,    -1,    -1,
  764.     -1,    51,    -1,    -1,    54,    55,    33,    34,    35,    36,
  765.     37,    38,    39,    40,    41,    -1,    -1,     3,     4,    46,
  766.     47,     7,     8,     9,    51,    -1,    12,    54,    55,    -1,
  767.     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  768.      3,     4,    -1,    -1,     7,     8,     9,    33,    -1,    12,
  769.     36,    37,    38,    39,    -1,    -1,    -1,    43,    44,    45,
  770.     46,    47,    -1,    -1,    -1,    51,    -1,    -1,    54,    55,
  771.     33,    34,    35,    36,    37,    38,    39,    40,    -1,    -1,
  772.     -1,     3,     4,    46,    47,     7,     8,     9,    51,    -1,
  773.     12,    54,    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  774.     -1,     3,     4,    -1,    -1,     7,     8,     9,    -1,    -1,
  775.     12,    33,    34,    -1,    36,    37,    38,    39,    -1,    -1,
  776.     -1,    -1,     3,     4,    46,    47,     7,     8,    -1,    51,
  777.     -1,    33,    54,    55,    36,    37,    38,    39,    -1,    -1,
  778.     -1,    -1,    -1,    -1,    46,    47,    -1,    -1,    -1,    51,
  779.     31,    -1,    54,    55,    -1,    36,    37,    38,    39,     3,
  780.      4,    -1,    -1,     7,     8,    46,    47,    -1,    49,    -1,
  781.     51,    -1,    -1,    54,    55,    -1,    -1,    -1,    -1,    -1,
  782.      3,     4,    -1,    -1,     7,     8,    -1,    31,    -1,    -1,
  783.     -1,    -1,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
  784.     -1,    -1,    46,    47,    -1,    49,    -1,    51,    31,    -1,
  785.     54,    55,    -1,    36,    37,    38,    39,     3,     4,    -1,
  786.     -1,     7,     8,    46,    47,    -1,    49,    -1,    51,    -1,
  787.     -1,    54,    55,    -1,    -1,    -1,    -1,     3,     4,    -1,
  788.     -1,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  789.     36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,
  790.     46,    47,    -1,    49,    -1,    51,    -1,    -1,    54,    55,
  791.     36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,
  792.     46,    47,    -1,    -1,    -1,    51,    -1,    -1,    54,    55
  793. };
  794. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  795. #line 3 "/usr/local/lib/bison.simple"
  796.  
  797. /* Skeleton output parser for bison,
  798.    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
  799.  
  800.    This program is free software; you can redistribute it and/or modify
  801.    it under the terms of the GNU General Public License as published by
  802.    the Free Software Foundation; either version 1, or (at your option)
  803.    any later version.
  804.  
  805.    This program is distributed in the hope that it will be useful,
  806.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  807.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  808.    GNU General Public License for more details.
  809.  
  810.    You should have received a copy of the GNU General Public License
  811.    along with this program; if not, write to the Free Software
  812.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  813.  
  814.  
  815. #ifndef alloca
  816. #ifdef __GNUC__
  817. #define alloca __builtin_alloca
  818. #else /* not GNU C.  */
  819. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
  820. #include <alloca.h>
  821. #else /* not sparc */
  822. #if defined (MSDOS) && !defined (__TURBOC__)
  823. #include <malloc.h>
  824. #else /* not MSDOS, or __TURBOC__ */
  825. #if defined(_AIX)
  826. #include <malloc.h>
  827.  #pragma alloca
  828. #else /* not MSDOS, __TURBOC__, or _AIX */
  829. #ifdef __hpux
  830. #ifdef __cplusplus
  831. extern "C" {
  832. void *alloca (unsigned int);
  833. };
  834. #else /* not __cplusplus */
  835. void *alloca ();
  836. #endif /* not __cplusplus */
  837. #endif /* __hpux */
  838. #endif /* not _AIX */
  839. #endif /* not MSDOS, or __TURBOC__ */
  840. #endif /* not sparc.  */
  841. #endif /* not GNU C.  */
  842. #endif /* alloca not defined.  */
  843.  
  844. /* This is the parser code that is written into each bison parser
  845.   when the %semantic_parser declaration is not specified in the grammar.
  846.   It was written by Richard Stallman by simplifying the hairy parser
  847.   used when %semantic_parser is specified.  */
  848.  
  849. /* Note: there must be only one dollar sign in this file.
  850.    It is replaced by the list of actions, each action
  851.    as one case of the switch.  */
  852.  
  853. #define yyerrok        (yyerrstatus = 0)
  854. #define yyclearin    (yychar = YYEMPTY)
  855. #define YYEMPTY        -2
  856. #define YYEOF        0
  857. #define YYACCEPT    return(0)
  858. #define YYABORT     return(1)
  859. #define YYERROR        goto yyerrlab1
  860. /* Like YYERROR except do call yyerror.
  861.    This remains here temporarily to ease the
  862.    transition to the new meaning of YYERROR, for GCC.
  863.    Once GCC version 2 has supplanted version 1, this can go.  */
  864. #define YYFAIL        goto yyerrlab
  865. #define YYRECOVERING()  (!!yyerrstatus)
  866. #define YYBACKUP(token, value) \
  867. do                                \
  868.   if (yychar == YYEMPTY && yylen == 1)                \
  869.     { yychar = (token), yylval = (value);            \
  870.       yychar1 = YYTRANSLATE (yychar);                \
  871.       YYPOPSTACK;                        \
  872.       goto yybackup;                        \
  873.     }                                \
  874.   else                                \
  875.     { yyerror ("syntax error: cannot back up"); YYERROR; }    \
  876. while (0)
  877.  
  878. #define YYTERROR    1
  879. #define YYERRCODE    256
  880.  
  881. #ifndef YYPURE
  882. #define YYLEX        yylex()
  883. #endif
  884.  
  885. #ifdef YYPURE
  886. #ifdef YYLSP_NEEDED
  887. #define YYLEX        yylex(&yylval, &yylloc)
  888. #else
  889. #define YYLEX        yylex(&yylval)
  890. #endif
  891. #endif
  892.  
  893. /* If nonreentrant, generate the variables here */
  894.  
  895. #ifndef YYPURE
  896.  
  897. int    yychar;            /*  the lookahead symbol        */
  898. YYSTYPE    yylval;            /*  the semantic value of the        */
  899.                 /*  lookahead symbol            */
  900.  
  901. #ifdef YYLSP_NEEDED
  902. YYLTYPE yylloc;            /*  location data for the lookahead    */
  903.                 /*  symbol                */
  904. #endif
  905.  
  906. int yynerrs;            /*  number of parse errors so far       */
  907. #endif  /* not YYPURE */
  908.  
  909. #if YYDEBUG != 0
  910. int yydebug;            /*  nonzero means print parse trace    */
  911. /* Since this is uninitialized, it does not stop multiple parsers
  912.    from coexisting.  */
  913. #endif
  914.  
  915. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  916.  
  917. #ifndef    YYINITDEPTH
  918. #define YYINITDEPTH 200
  919. #endif
  920.  
  921. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  922.     (effective only if the built-in stack extension method is used).  */
  923.  
  924. #if YYMAXDEPTH == 0
  925. #undef YYMAXDEPTH
  926. #endif
  927.  
  928. #ifndef YYMAXDEPTH
  929. #define YYMAXDEPTH 10000
  930. #endif
  931.  
  932. /* Prevent warning if -Wstrict-prototypes.  */
  933. #ifdef __GNUC__
  934. int yyparse (void);
  935. #endif
  936.  
  937. #if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
  938. #define __yy_bcopy(FROM,TO,COUNT)    __builtin_memcpy(TO,FROM,COUNT)
  939. #else                /* not GNU C or C++ */
  940. #ifndef __cplusplus
  941.  
  942. /* This is the most reliable way to avoid incompatibilities
  943.    in available built-in functions on various systems.  */
  944. static void
  945. __yy_bcopy (from, to, count)
  946.      char *from;
  947.      char *to;
  948.      int count;
  949. {
  950.   register char *f = from;
  951.   register char *t = to;
  952.   register int i = count;
  953.  
  954.   while (i-- > 0)
  955.     *t++ = *f++;
  956. }
  957.  
  958. #else /* __cplusplus */
  959.  
  960. /* This is the most reliable way to avoid incompatibilities
  961.    in available built-in functions on various systems.  */
  962. static void
  963. __yy_bcopy (char *from, char *to, int count)
  964. {
  965.   register char *f = from;
  966.   register char *t = to;
  967.   register int i = count;
  968.  
  969.   while (i-- > 0)
  970.     *t++ = *f++;
  971. }
  972.  
  973. #endif
  974. #endif
  975.  
  976. #line 184 "/usr/local/lib/bison.simple"
  977. int
  978. yyparse()
  979. {
  980.   register int yystate;
  981.   register int yyn;
  982.   register short *yyssp;
  983.   register YYSTYPE *yyvsp;
  984.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  985.   int yychar1 = 0;        /*  lookahead token as an internal (translated) token number */
  986.  
  987.   short    yyssa[YYINITDEPTH];    /*  the state stack            */
  988.   YYSTYPE yyvsa[YYINITDEPTH];    /*  the semantic value stack        */
  989.  
  990.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  991.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  992.  
  993. #ifdef YYLSP_NEEDED
  994.   YYLTYPE yylsa[YYINITDEPTH];    /*  the location stack            */
  995.   YYLTYPE *yyls = yylsa;
  996.   YYLTYPE *yylsp;
  997.  
  998. #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
  999. #else
  1000. #define YYPOPSTACK   (yyvsp--, yyssp--)
  1001. #endif
  1002.  
  1003.   int yystacksize = YYINITDEPTH;
  1004.  
  1005. #ifdef YYPURE
  1006.   int yychar;
  1007.   YYSTYPE yylval;
  1008.   int yynerrs;
  1009. #ifdef YYLSP_NEEDED
  1010.   YYLTYPE yylloc;
  1011. #endif
  1012. #endif
  1013.  
  1014.   YYSTYPE yyval;        /*  the variable used to return        */
  1015.                 /*  semantic values from the action    */
  1016.                 /*  routines                */
  1017.  
  1018.   int yylen;
  1019.  
  1020. #if YYDEBUG != 0
  1021.   if (yydebug)
  1022.     fprintf(stderr, "Starting parse\n");
  1023. #endif
  1024.  
  1025.   yystate = 0;
  1026.   yyerrstatus = 0;
  1027.   yynerrs = 0;
  1028.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  1029.  
  1030.   /* Initialize stack pointers.
  1031.      Waste one element of value and location stack
  1032.      so that they stay on the same level as the state stack.
  1033.      The wasted elements are never initialized.  */
  1034.  
  1035.   yyssp = yyss - 1;
  1036.   yyvsp = yyvs;
  1037. #ifdef YYLSP_NEEDED
  1038.   yylsp = yyls;
  1039. #endif
  1040.  
  1041. /* Push a new state, which is found in  yystate  .  */
  1042. /* In all cases, when you get here, the value and location stacks
  1043.    have just been pushed. so pushing a state here evens the stacks.  */
  1044. yynewstate:
  1045.  
  1046.   *++yyssp = yystate;
  1047.  
  1048.   if (yyssp >= yyss + yystacksize - 1)
  1049.     {
  1050.       /* Give user a chance to reallocate the stack */
  1051.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  1052.       YYSTYPE *yyvs1 = yyvs;
  1053.       short *yyss1 = yyss;
  1054. #ifdef YYLSP_NEEDED
  1055.       YYLTYPE *yyls1 = yyls;
  1056. #endif
  1057.  
  1058.       /* Get the current used size of the three stacks, in elements.  */
  1059.       int size = yyssp - yyss + 1;
  1060.  
  1061. #ifdef yyoverflow
  1062.       /* Each stack pointer address is followed by the size of
  1063.      the data in use in that stack, in bytes.  */
  1064. #ifdef YYLSP_NEEDED
  1065.       /* This used to be a conditional around just the two extra args,
  1066.      but that might be undefined if yyoverflow is a macro.  */
  1067.       yyoverflow("parser stack overflow",
  1068.          &yyss1, size * sizeof (*yyssp),
  1069.          &yyvs1, size * sizeof (*yyvsp),
  1070.          &yyls1, size * sizeof (*yylsp),
  1071.          &yystacksize);
  1072. #else
  1073.       yyoverflow("parser stack overflow",
  1074.          &yyss1, size * sizeof (*yyssp),
  1075.          &yyvs1, size * sizeof (*yyvsp),
  1076.          &yystacksize);
  1077. #endif
  1078.  
  1079.       yyss = yyss1; yyvs = yyvs1;
  1080. #ifdef YYLSP_NEEDED
  1081.       yyls = yyls1;
  1082. #endif
  1083. #else /* no yyoverflow */
  1084.       /* Extend the stack our own way.  */
  1085.       if (yystacksize >= YYMAXDEPTH)
  1086.     {
  1087.       yyerror("parser stack overflow");
  1088.       return 2;
  1089.     }
  1090.       yystacksize *= 2;
  1091.       if (yystacksize > YYMAXDEPTH)
  1092.     yystacksize = YYMAXDEPTH;
  1093.       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
  1094.       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  1095.       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
  1096.       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  1097. #ifdef YYLSP_NEEDED
  1098.       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
  1099.       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  1100. #endif
  1101. #endif /* no yyoverflow */
  1102.  
  1103.       yyssp = yyss + size - 1;
  1104.       yyvsp = yyvs + size - 1;
  1105. #ifdef YYLSP_NEEDED
  1106.       yylsp = yyls + size - 1;
  1107. #endif
  1108.  
  1109. #if YYDEBUG != 0
  1110.       if (yydebug)
  1111.     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
  1112. #endif
  1113.  
  1114.       if (yyssp >= yyss + yystacksize - 1)
  1115.     YYABORT;
  1116.     }
  1117.  
  1118. #if YYDEBUG != 0
  1119.   if (yydebug)
  1120.     fprintf(stderr, "Entering state %d\n", yystate);
  1121. #endif
  1122.  
  1123.   goto yybackup;
  1124.  yybackup:
  1125.  
  1126. /* Do appropriate processing given the current state.  */
  1127. /* Read a lookahead token if we need one and don't already have one.  */
  1128. /* yyresume: */
  1129.  
  1130.   /* First try to decide what to do without reference to lookahead token.  */
  1131.  
  1132.   yyn = yypact[yystate];
  1133.   if (yyn == YYFLAG)
  1134.     goto yydefault;
  1135.  
  1136.   /* Not known => get a lookahead token if don't already have one.  */
  1137.  
  1138.   /* yychar is either YYEMPTY or YYEOF
  1139.      or a valid token in external form.  */
  1140.  
  1141.   if (yychar == YYEMPTY)
  1142.     {
  1143. #if YYDEBUG != 0
  1144.       if (yydebug)
  1145.     fprintf(stderr, "Reading a token: ");
  1146. #endif
  1147.       yychar = YYLEX;
  1148.     }
  1149.  
  1150.   /* Convert token to internal form (in yychar1) for indexing tables with */
  1151.  
  1152.   if (yychar <= 0)        /* This means end of input. */
  1153.     {
  1154.       yychar1 = 0;
  1155.       yychar = YYEOF;        /* Don't call YYLEX any more */
  1156.  
  1157. #if YYDEBUG != 0
  1158.       if (yydebug)
  1159.     fprintf(stderr, "Now at end of input.\n");
  1160. #endif
  1161.     }
  1162.   else
  1163.     {
  1164.       yychar1 = YYTRANSLATE(yychar);
  1165.  
  1166. #if YYDEBUG != 0
  1167.       if (yydebug)
  1168.     {
  1169.       fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
  1170.       /* Give the individual parser a way to print the precise meaning
  1171.          of a token, for further debugging info.  */
  1172. #ifdef YYPRINT
  1173.       YYPRINT (stderr, yychar, yylval);
  1174. #endif
  1175.       fprintf (stderr, ")\n");
  1176.     }
  1177. #endif
  1178.     }
  1179.  
  1180.   yyn += yychar1;
  1181.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  1182.     goto yydefault;
  1183.  
  1184.   yyn = yytable[yyn];
  1185.  
  1186.   /* yyn is what to do for this token type in this state.
  1187.      Negative => reduce, -yyn is rule number.
  1188.      Positive => shift, yyn is new state.
  1189.        New state is final state => don't bother to shift,
  1190.        just return success.
  1191.      0, or most negative number => error.  */
  1192.  
  1193.   if (yyn < 0)
  1194.     {
  1195.       if (yyn == YYFLAG)
  1196.     goto yyerrlab;
  1197.       yyn = -yyn;
  1198.       goto yyreduce;
  1199.     }
  1200.   else if (yyn == 0)
  1201.     goto yyerrlab;
  1202.  
  1203.   if (yyn == YYFINAL)
  1204.     YYACCEPT;
  1205.  
  1206.   /* Shift the lookahead token.  */
  1207.  
  1208. #if YYDEBUG != 0
  1209.   if (yydebug)
  1210.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  1211. #endif
  1212.  
  1213.   /* Discard the token being shifted unless it is eof.  */
  1214.   if (yychar != YYEOF)
  1215.     yychar = YYEMPTY;
  1216.  
  1217.   *++yyvsp = yylval;
  1218. #ifdef YYLSP_NEEDED
  1219.   *++yylsp = yylloc;
  1220. #endif
  1221.  
  1222.   /* count tokens shifted since error; after three, turn off error status.  */
  1223.   if (yyerrstatus) yyerrstatus--;
  1224.  
  1225.   yystate = yyn;
  1226.   goto yynewstate;
  1227.  
  1228. /* Do the default action for the current state.  */
  1229. yydefault:
  1230.  
  1231.   yyn = yydefact[yystate];
  1232.   if (yyn == 0)
  1233.     goto yyerrlab;
  1234.  
  1235. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  1236. yyreduce:
  1237.   yylen = yyr2[yyn];
  1238.   if (yylen > 0)
  1239.     yyval = yyvsp[1-yylen]; /* implement default value of the action */
  1240.  
  1241. #if YYDEBUG != 0
  1242.   if (yydebug)
  1243.     {
  1244.       int i;
  1245.  
  1246.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  1247.            yyn, yyrline[yyn]);
  1248.  
  1249.       /* Print the symbols being reduced, and their result.  */
  1250.       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
  1251.     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
  1252.       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
  1253.     }
  1254. #endif
  1255.  
  1256.  
  1257.   switch (yyn) {
  1258.  
  1259. case 1:
  1260. #line 150 "./awk.y"
  1261. {
  1262.             expression_value = yyvsp[-1].nodeval;
  1263.             check_funcs();
  1264.         ;
  1265.     break;}
  1266. case 2:
  1267. #line 158 "./awk.y"
  1268. { 
  1269.             if (yyvsp[0].nodeval != NULL)
  1270.                 yyval.nodeval = yyvsp[0].nodeval;
  1271.             else
  1272.                 yyval.nodeval = NULL;
  1273.             yyerrok;
  1274.         ;
  1275.     break;}
  1276. case 3:
  1277. #line 167 "./awk.y"
  1278. {
  1279.             if (yyvsp[0].nodeval == NULL)
  1280.                 yyval.nodeval = yyvsp[-1].nodeval;
  1281.             else if (yyvsp[-1].nodeval == NULL)
  1282.                 yyval.nodeval = yyvsp[0].nodeval;
  1283.             else {
  1284.                 if (yyvsp[-1].nodeval->type != Node_rule_list)
  1285.                     yyvsp[-1].nodeval = node(yyvsp[-1].nodeval, Node_rule_list,
  1286.                         (NODE*) NULL);
  1287.                 yyval.nodeval = append_right(yyvsp[-1].nodeval,
  1288.                    node(yyvsp[0].nodeval, Node_rule_list, (NODE *) NULL));
  1289.             }
  1290.             yyerrok;
  1291.         ;
  1292.     break;}
  1293. case 4:
  1294. #line 181 "./awk.y"
  1295. { yyval.nodeval = NULL; ;
  1296.     break;}
  1297. case 5:
  1298. #line 182 "./awk.y"
  1299. { yyval.nodeval = NULL; ;
  1300.     break;}
  1301. case 6:
  1302. #line 183 "./awk.y"
  1303. { yyval.nodeval = NULL; ;
  1304.     break;}
  1305. case 7:
  1306. #line 187 "./awk.y"
  1307. { io_allowed = FALSE; ;
  1308.     break;}
  1309. case 8:
  1310. #line 189 "./awk.y"
  1311. {
  1312.         if (begin_block != NULL) {
  1313.             if (begin_block->type != Node_rule_list)
  1314.                 begin_block = node(begin_block, Node_rule_list,
  1315.                     (NODE *) NULL);
  1316.             (void) append_right(begin_block, node(
  1317.                 node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval),
  1318.                 Node_rule_list, (NODE *) NULL) );
  1319.         } else
  1320.             begin_block = node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval);
  1321.         yyval.nodeval = NULL;
  1322.         io_allowed = TRUE;
  1323.         yyerrok;
  1324.       ;
  1325.     break;}
  1326. case 9:
  1327. #line 203 "./awk.y"
  1328. { io_allowed = FALSE; ;
  1329.     break;}
  1330. case 10:
  1331. #line 205 "./awk.y"
  1332. {
  1333.         if (end_block != NULL) {
  1334.             if (end_block->type != Node_rule_list)
  1335.                 end_block = node(end_block, Node_rule_list,
  1336.                     (NODE *) NULL);
  1337.             (void) append_right (end_block, node(
  1338.                 node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval),
  1339.                 Node_rule_list, (NODE *) NULL));
  1340.         } else
  1341.             end_block = node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval);
  1342.         yyval.nodeval = NULL;
  1343.         io_allowed = TRUE;
  1344.         yyerrok;
  1345.       ;
  1346.     break;}
  1347. case 11:
  1348. #line 220 "./awk.y"
  1349. {
  1350.         warning("BEGIN blocks must have an action part");
  1351.         errcount++;
  1352.         yyerrok;
  1353.       ;
  1354.     break;}
  1355. case 12:
  1356. #line 226 "./awk.y"
  1357. {
  1358.         warning("END blocks must have an action part");
  1359.         errcount++;
  1360.         yyerrok;
  1361.       ;
  1362.     break;}
  1363. case 13:
  1364. #line 232 "./awk.y"
  1365. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_rule_node, yyvsp[0].nodeval); yyerrok; ;
  1366.     break;}
  1367. case 14:
  1368. #line 234 "./awk.y"
  1369. { yyval.nodeval = node((NODE *) NULL, Node_rule_node, yyvsp[0].nodeval); yyerrok; ;
  1370.     break;}
  1371. case 15:
  1372. #line 236 "./awk.y"
  1373. {
  1374.           yyval.nodeval = node(yyvsp[-1].nodeval,
  1375.                  Node_rule_node,
  1376.                  node(node(node(make_number(0.0),
  1377.                         Node_field_spec,
  1378.                         (NODE *) NULL),
  1379.                     Node_expression_list,
  1380.                     (NODE *) NULL),
  1381.                   Node_K_print,
  1382.                   (NODE *) NULL));
  1383.           yyerrok;
  1384.         ;
  1385.     break;}
  1386. case 16:
  1387. #line 249 "./awk.y"
  1388. {
  1389.             func_install(yyvsp[-1].nodeval, yyvsp[0].nodeval);
  1390.             yyval.nodeval = NULL;
  1391.             yyerrok;
  1392.         ;
  1393.     break;}
  1394. case 17:
  1395. #line 258 "./awk.y"
  1396. { yyval.sval = yyvsp[0].sval; ;
  1397.     break;}
  1398. case 18:
  1399. #line 260 "./awk.y"
  1400. { yyval.sval = yyvsp[0].sval; ;
  1401.     break;}
  1402. case 19:
  1403. #line 262 "./awk.y"
  1404. {
  1405.         yyerror("%s() is a built-in function, it cannot be redefined",
  1406.             tokstart);
  1407.         errcount++;
  1408.         /* yyerrok; */
  1409.       ;
  1410.     break;}
  1411. case 22:
  1412. #line 277 "./awk.y"
  1413. {
  1414.             param_counter = 0;
  1415.         ;
  1416.     break;}
  1417. case 23:
  1418. #line 281 "./awk.y"
  1419. {
  1420.             yyval.nodeval = append_right(make_param(yyvsp[-4].sval), yyvsp[-2].nodeval);
  1421.             can_return = TRUE;
  1422.             /* check for duplicate parameter names */
  1423.             if (dup_parms(yyval.nodeval))
  1424.                 errcount++;
  1425.         ;
  1426.     break;}
  1427. case 24:
  1428. #line 292 "./awk.y"
  1429. {
  1430.         yyval.nodeval = yyvsp[-2].nodeval;
  1431.         can_return = FALSE;
  1432.       ;
  1433.     break;}
  1434. case 25:
  1435. #line 297 "./awk.y"
  1436. {
  1437.         yyval.nodeval = node((NODE *) NULL, Node_K_return, (NODE *) NULL);
  1438.         can_return = FALSE;
  1439.       ;
  1440.     break;}
  1441. case 26:
  1442. #line 306 "./awk.y"
  1443. { yyval.nodeval = yyvsp[0].nodeval; ;
  1444.     break;}
  1445. case 27:
  1446. #line 308 "./awk.y"
  1447. { yyval.nodeval = mkrangenode(node(yyvsp[-2].nodeval, Node_cond_pair, yyvsp[0].nodeval)); ;
  1448.     break;}
  1449. case 28:
  1450. #line 317 "./awk.y"
  1451. { ++want_regexp; ;
  1452.     break;}
  1453. case 29:
  1454. #line 319 "./awk.y"
  1455. {
  1456.           NODE *n;
  1457.           size_t len;
  1458.  
  1459.           getnode(n);
  1460.           n->type = Node_regex;
  1461.           len = strlen(yyvsp[-1].sval);
  1462.           n->re_exp = make_string(yyvsp[-1].sval, len);
  1463.           n->re_reg = make_regexp(yyvsp[-1].sval, len, FALSE, TRUE);
  1464.           n->re_text = NULL;
  1465.           n->re_flags = CONST;
  1466.           n->re_cnt = 1;
  1467.           yyval.nodeval = n;
  1468.         ;
  1469.     break;}
  1470. case 30:
  1471. #line 337 "./awk.y"
  1472. { yyval.nodeval = yyvsp[-3].nodeval; ;
  1473.     break;}
  1474. case 31:
  1475. #line 339 "./awk.y"
  1476. { yyval.nodeval = NULL; ;
  1477.     break;}
  1478. case 32:
  1479. #line 344 "./awk.y"
  1480. {
  1481.             yyval.nodeval = yyvsp[0].nodeval;
  1482.             if (do_lint && isnoeffect(yyval.nodeval->type))
  1483.                 warning("statement may have no effect");
  1484.         ;
  1485.     break;}
  1486. case 33:
  1487. #line 350 "./awk.y"
  1488. {
  1489.             if (yyvsp[-1].nodeval == NULL || yyvsp[-1].nodeval->type != Node_statement_list)
  1490.                 yyvsp[-1].nodeval = node(yyvsp[-1].nodeval, Node_statement_list, (NODE *) NULL);
  1491.                 yyval.nodeval = append_right(yyvsp[-1].nodeval,
  1492.                 node(yyvsp[0].nodeval, Node_statement_list, (NODE *)   NULL));
  1493.                 yyerrok;
  1494.         ;
  1495.     break;}
  1496. case 34:
  1497. #line 358 "./awk.y"
  1498. { yyval.nodeval = NULL; ;
  1499.     break;}
  1500. case 35:
  1501. #line 360 "./awk.y"
  1502. { yyval.nodeval = NULL; ;
  1503.     break;}
  1504. case 38:
  1505. #line 370 "./awk.y"
  1506. { yyval.nodeval = NULL; ;
  1507.     break;}
  1508. case 39:
  1509. #line 372 "./awk.y"
  1510. { yyval.nodeval = NULL; ;
  1511.     break;}
  1512. case 40:
  1513. #line 374 "./awk.y"
  1514. { yyval.nodeval = yyvsp[-1].nodeval; ;
  1515.     break;}
  1516. case 41:
  1517. #line 376 "./awk.y"
  1518. { yyval.nodeval = yyvsp[0].nodeval; ;
  1519.     break;}
  1520. case 42:
  1521. #line 378 "./awk.y"
  1522. { yyval.nodeval = node(yyvsp[-3].nodeval, Node_K_while, yyvsp[0].nodeval); ;
  1523.     break;}
  1524. case 43:
  1525. #line 380 "./awk.y"
  1526. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_K_do, yyvsp[-5].nodeval); ;
  1527.     break;}
  1528. case 44:
  1529. #line 382 "./awk.y"
  1530. {
  1531.         yyval.nodeval = node(yyvsp[0].nodeval, Node_K_arrayfor,
  1532.             make_for_loop(variable(yyvsp[-5].sval, CAN_FREE, Node_var),
  1533.             (NODE *) NULL, variable(yyvsp[-3].sval, CAN_FREE, Node_var_array)));
  1534.       ;
  1535.     break;}
  1536. case 45:
  1537. #line 388 "./awk.y"
  1538. {
  1539.         yyval.nodeval = node(yyvsp[0].nodeval, Node_K_for, (NODE *) make_for_loop(yyvsp[-7].nodeval, yyvsp[-5].nodeval, yyvsp[-3].nodeval));
  1540.       ;
  1541.     break;}
  1542. case 46:
  1543. #line 392 "./awk.y"
  1544. {
  1545.         yyval.nodeval = node(yyvsp[0].nodeval, Node_K_for,
  1546.             (NODE *) make_for_loop(yyvsp[-6].nodeval, (NODE *) NULL, yyvsp[-3].nodeval));
  1547.       ;
  1548.     break;}
  1549. case 47:
  1550. #line 398 "./awk.y"
  1551. { yyval.nodeval = node((NODE *) NULL, Node_K_break, (NODE *) NULL); ;
  1552.     break;}
  1553. case 48:
  1554. #line 401 "./awk.y"
  1555. { yyval.nodeval = node((NODE *) NULL, Node_K_continue, (NODE *) NULL); ;
  1556.     break;}
  1557. case 49:
  1558. #line 403 "./awk.y"
  1559. { yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-5].nodetypeval, yyvsp[-1].nodeval); ;
  1560.     break;}
  1561. case 50:
  1562. #line 405 "./awk.y"
  1563. {
  1564.             if (yyvsp[-3].nodetypeval == Node_K_print && yyvsp[-2].nodeval == NULL) {
  1565.                 static int warned = FALSE;
  1566.  
  1567.                 yyvsp[-2].nodeval = node(node(make_number(0.0),
  1568.                            Node_field_spec,
  1569.                            (NODE *) NULL),
  1570.                       Node_expression_list,
  1571.                       (NODE *) NULL);
  1572.  
  1573.                 if (do_lint && ! io_allowed && ! warned) {
  1574.                     warned = TRUE;
  1575.                     warning(
  1576.     "plain `print' in BEGIN or END rule should probably be `print \"\"'");
  1577.                 }
  1578.             }
  1579.  
  1580.             yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-3].nodetypeval, yyvsp[-1].nodeval);
  1581.         ;
  1582.     break;}
  1583. case 51:
  1584. #line 425 "./awk.y"
  1585. { NODETYPE type;
  1586.  
  1587.           if (yyvsp[-1].nodeval) {
  1588.             if (yyvsp[-1].nodeval == lookup("file")) {
  1589.                 static int warned = FALSE;
  1590.  
  1591.                 if (! warned) {
  1592.                     warned = TRUE;
  1593.                     warning("`next file' is obsolete; use `nextfile'");
  1594.                 }
  1595.                 if (do_lint)
  1596.                     warning("`next file' is a gawk extension");
  1597.                 if (do_traditional) {
  1598.                     /*
  1599.                      * can't use yyerror, since may have overshot
  1600.                      * the source line
  1601.                      */
  1602.                     errcount++;
  1603.                     error("`next file' is a gawk extension");
  1604.                 }
  1605.                 if (! io_allowed) {
  1606.                     /* same thing */
  1607.                     errcount++;
  1608.                     error("`next file' used in BEGIN or END action");
  1609.                 }
  1610.                 type = Node_K_nextfile;
  1611.             } else {
  1612.                 errcount++;
  1613.                 error("illegal expression after `next'");
  1614.                 type = Node_K_next;    /* sanity */
  1615.             }
  1616.           } else {
  1617.             if (! io_allowed)
  1618.                 yyerror("`next' used in BEGIN or END action");
  1619.             type = Node_K_next;
  1620.           }
  1621.           yyval.nodeval = node((NODE *) NULL, type, (NODE *) NULL);
  1622.         ;
  1623.     break;}
  1624. case 52:
  1625. #line 464 "./awk.y"
  1626. {
  1627.           if (do_lint)
  1628.             warning("`nextfile' is a gawk extension");
  1629.           if (do_traditional) {
  1630.             /*
  1631.              * can't use yyerror, since may have overshot
  1632.              * the source line
  1633.              */
  1634.             errcount++;
  1635.             error("`nextfile' is a gawk extension");
  1636.           }
  1637.           if (! io_allowed) {
  1638.             /* same thing */
  1639.             errcount++;
  1640.             error("`nextfile' used in BEGIN or END action");
  1641.           }
  1642.           yyval.nodeval = node((NODE *) NULL, Node_K_nextfile, (NODE *) NULL);
  1643.         ;
  1644.     break;}
  1645. case 53:
  1646. #line 483 "./awk.y"
  1647. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_exit, (NODE *) NULL); ;
  1648.     break;}
  1649. case 54:
  1650. #line 485 "./awk.y"
  1651. {
  1652.           if (! can_return)
  1653.             yyerror("`return' used outside function context");
  1654.         ;
  1655.     break;}
  1656. case 55:
  1657. #line 490 "./awk.y"
  1658. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_return, (NODE *) NULL); ;
  1659.     break;}
  1660. case 56:
  1661. #line 492 "./awk.y"
  1662. { yyval.nodeval = node(variable(yyvsp[-4].sval, CAN_FREE, Node_var_array), Node_K_delete, yyvsp[-2].nodeval); ;
  1663.     break;}
  1664. case 57:
  1665. #line 494 "./awk.y"
  1666. {
  1667.           if (do_lint)
  1668.             warning("`delete array' is a gawk extension");
  1669.           if (do_traditional) {
  1670.             /*
  1671.              * can't use yyerror, since may have overshot
  1672.              * the source line
  1673.              */
  1674.             errcount++;
  1675.             error("`delete array' is a gawk extension");
  1676.           }
  1677.           yyval.nodeval = node(variable(yyvsp[-1].sval, CAN_FREE, Node_var_array), Node_K_delete, (NODE *) NULL);
  1678.         ;
  1679.     break;}
  1680. case 58:
  1681. #line 508 "./awk.y"
  1682. { yyval.nodeval = yyvsp[-1].nodeval; ;
  1683.     break;}
  1684. case 59:
  1685. #line 513 "./awk.y"
  1686. { yyval.nodetypeval = yyvsp[0].nodetypeval; ;
  1687.     break;}
  1688. case 60:
  1689. #line 515 "./awk.y"
  1690. { yyval.nodetypeval = yyvsp[0].nodetypeval; ;
  1691.     break;}
  1692. case 61:
  1693. #line 520 "./awk.y"
  1694. {
  1695.         yyval.nodeval = node(yyvsp[-3].nodeval, Node_K_if, 
  1696.             node(yyvsp[0].nodeval, Node_if_branches, (NODE *) NULL));
  1697.       ;
  1698.     break;}
  1699. case 62:
  1700. #line 526 "./awk.y"
  1701. { yyval.nodeval = node(yyvsp[-6].nodeval, Node_K_if,
  1702.                 node(yyvsp[-3].nodeval, Node_if_branches, yyvsp[0].nodeval)); ;
  1703.     break;}
  1704. case 63:
  1705. #line 532 "./awk.y"
  1706. { want_assign = FALSE; ;
  1707.     break;}
  1708. case 67:
  1709. #line 543 "./awk.y"
  1710. { yyval.nodeval = NULL; ;
  1711.     break;}
  1712. case 68:
  1713. #line 545 "./awk.y"
  1714. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_input, (NODE *) NULL); ;
  1715.     break;}
  1716. case 69:
  1717. #line 550 "./awk.y"
  1718. { yyval.nodeval = NULL; ;
  1719.     break;}
  1720. case 70:
  1721. #line 552 "./awk.y"
  1722. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_output, (NODE *) NULL); ;
  1723.     break;}
  1724. case 71:
  1725. #line 554 "./awk.y"
  1726. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_append, (NODE *) NULL); ;
  1727.     break;}
  1728. case 72:
  1729. #line 556 "./awk.y"
  1730. { yyval.nodeval = node(yyvsp[0].nodeval, Node_redirect_pipe, (NODE *) NULL); ;
  1731.     break;}
  1732. case 73:
  1733. #line 561 "./awk.y"
  1734. { yyval.nodeval = NULL; ;
  1735.     break;}
  1736. case 74:
  1737. #line 563 "./awk.y"
  1738. { yyval.nodeval = yyvsp[0].nodeval; ;
  1739.     break;}
  1740. case 75:
  1741. #line 568 "./awk.y"
  1742. { yyval.nodeval = make_param(yyvsp[0].sval); ;
  1743.     break;}
  1744. case 76:
  1745. #line 570 "./awk.y"
  1746. { yyval.nodeval = append_right(yyvsp[-2].nodeval, make_param(yyvsp[0].sval)); yyerrok; ;
  1747.     break;}
  1748. case 77:
  1749. #line 572 "./awk.y"
  1750. { yyval.nodeval = NULL; ;
  1751.     break;}
  1752. case 78:
  1753. #line 574 "./awk.y"
  1754. { yyval.nodeval = NULL; ;
  1755.     break;}
  1756. case 79:
  1757. #line 576 "./awk.y"
  1758. { yyval.nodeval = NULL; ;
  1759.     break;}
  1760. case 80:
  1761. #line 582 "./awk.y"
  1762. { yyval.nodeval = NULL; ;
  1763.     break;}
  1764. case 81:
  1765. #line 584 "./awk.y"
  1766. { yyval.nodeval = yyvsp[0].nodeval; ;
  1767.     break;}
  1768. case 82:
  1769. #line 589 "./awk.y"
  1770. { yyval.nodeval = NULL; ;
  1771.     break;}
  1772. case 83:
  1773. #line 591 "./awk.y"
  1774. { yyval.nodeval = yyvsp[0].nodeval; ;
  1775.     break;}
  1776. case 84:
  1777. #line 596 "./awk.y"
  1778. { yyval.nodeval = node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL); ;
  1779.     break;}
  1780. case 85:
  1781. #line 598 "./awk.y"
  1782. {
  1783.         yyval.nodeval = append_right(yyvsp[-2].nodeval,
  1784.             node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL));
  1785.         yyerrok;
  1786.       ;
  1787.     break;}
  1788. case 86:
  1789. #line 604 "./awk.y"
  1790. { yyval.nodeval = NULL; ;
  1791.     break;}
  1792. case 87:
  1793. #line 606 "./awk.y"
  1794. { yyval.nodeval = NULL; ;
  1795.     break;}
  1796. case 88:
  1797. #line 608 "./awk.y"
  1798. { yyval.nodeval = NULL; ;
  1799.     break;}
  1800. case 89:
  1801. #line 610 "./awk.y"
  1802. { yyval.nodeval = NULL; ;
  1803.     break;}
  1804. case 90:
  1805. #line 615 "./awk.y"
  1806. { yyval.nodeval = NULL; ;
  1807.     break;}
  1808. case 91:
  1809. #line 617 "./awk.y"
  1810. { yyval.nodeval = yyvsp[0].nodeval; ;
  1811.     break;}
  1812. case 92:
  1813. #line 622 "./awk.y"
  1814. { yyval.nodeval = node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL); ;
  1815.     break;}
  1816. case 93:
  1817. #line 624 "./awk.y"
  1818. {
  1819.             yyval.nodeval = append_right(yyvsp[-2].nodeval,
  1820.                 node(yyvsp[0].nodeval, Node_expression_list, (NODE *) NULL));
  1821.             yyerrok;
  1822.         ;
  1823.     break;}
  1824. case 94:
  1825. #line 630 "./awk.y"
  1826. { yyval.nodeval = NULL; ;
  1827.     break;}
  1828. case 95:
  1829. #line 632 "./awk.y"
  1830. { yyval.nodeval = NULL; ;
  1831.     break;}
  1832. case 96:
  1833. #line 634 "./awk.y"
  1834. { yyval.nodeval = NULL; ;
  1835.     break;}
  1836. case 97:
  1837. #line 636 "./awk.y"
  1838. { yyval.nodeval = NULL; ;
  1839.     break;}
  1840. case 98:
  1841. #line 641 "./awk.y"
  1842. { want_assign = FALSE; ;
  1843.     break;}
  1844. case 99:
  1845. #line 643 "./awk.y"
  1846. {
  1847.           if (do_lint && yyvsp[0].nodeval->type == Node_regex)
  1848.             warning("Regular expression on left of assignment.");
  1849.           yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-2].nodetypeval, yyvsp[0].nodeval);
  1850.         ;
  1851.     break;}
  1852. case 100:
  1853. #line 649 "./awk.y"
  1854. { yyval.nodeval = node(variable(yyvsp[0].sval, CAN_FREE, Node_var_array), Node_in_array, yyvsp[-3].nodeval); ;
  1855.     break;}
  1856. case 101:
  1857. #line 651 "./awk.y"
  1858. {
  1859.           yyval.nodeval = node(yyvsp[0].nodeval, Node_K_getline,
  1860.              node(yyvsp[-3].nodeval, Node_redirect_pipein, (NODE *) NULL));
  1861.         ;
  1862.     break;}
  1863. case 102:
  1864. #line 656 "./awk.y"
  1865. {
  1866.           if (do_lint && ! io_allowed && yyvsp[0].nodeval == NULL)
  1867.             warning("non-redirected getline undefined inside BEGIN or END action");
  1868.           yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_getline, yyvsp[0].nodeval);
  1869.         ;
  1870.     break;}
  1871. case 103:
  1872. #line 662 "./awk.y"
  1873. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_and, yyvsp[0].nodeval); ;
  1874.     break;}
  1875. case 104:
  1876. #line 664 "./awk.y"
  1877. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_or, yyvsp[0].nodeval); ;
  1878.     break;}
  1879. case 105:
  1880. #line 666 "./awk.y"
  1881. {
  1882.           if (yyvsp[-2].nodeval->type == Node_regex)
  1883.             warning("Regular expression on left of MATCH operator.");
  1884.           yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, mk_rexp(yyvsp[0].nodeval));
  1885.         ;
  1886.     break;}
  1887. case 106:
  1888. #line 672 "./awk.y"
  1889. {
  1890.           yyval.nodeval = yyvsp[0].nodeval;
  1891.           if (do_lint && tokstart[0] == '*') {
  1892.             /* possible C comment */
  1893.             int n = strlen(tokstart) - 1;
  1894.             if (tokstart[n] == '*')
  1895.                 warning("regexp looks like a C comment, but is not");
  1896.           }
  1897.         ;
  1898.     break;}
  1899. case 107:
  1900. #line 682 "./awk.y"
  1901. {
  1902.           yyval.nodeval = node(node(make_number(0.0),
  1903.                  Node_field_spec,
  1904.                  (NODE *) NULL),
  1905.                     Node_nomatch,
  1906.                 yyvsp[0].nodeval);
  1907.         ;
  1908.     break;}
  1909. case 108:
  1910. #line 690 "./awk.y"
  1911. { yyval.nodeval = node(variable(yyvsp[0].sval, CAN_FREE, Node_var_array), Node_in_array, yyvsp[-2].nodeval); ;
  1912.     break;}
  1913. case 109:
  1914. #line 692 "./awk.y"
  1915. {
  1916.           if (do_lint && yyvsp[0].nodeval->type == Node_regex)
  1917.             warning("Regular expression on left of comparison.");
  1918.           yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval);
  1919.         ;
  1920.     break;}
  1921. case 110:
  1922. #line 698 "./awk.y"
  1923. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_less, yyvsp[0].nodeval); ;
  1924.     break;}
  1925. case 111:
  1926. #line 700 "./awk.y"
  1927. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_greater, yyvsp[0].nodeval); ;
  1928.     break;}
  1929. case 112:
  1930. #line 702 "./awk.y"
  1931. { yyval.nodeval = node(yyvsp[-4].nodeval, Node_cond_exp, node(yyvsp[-2].nodeval, Node_if_branches, yyvsp[0].nodeval));;
  1932.     break;}
  1933. case 113:
  1934. #line 704 "./awk.y"
  1935. { yyval.nodeval = yyvsp[0].nodeval; ;
  1936.     break;}
  1937. case 114:
  1938. #line 706 "./awk.y"
  1939. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_concat, yyvsp[0].nodeval); ;
  1940.     break;}
  1941. case 115:
  1942. #line 711 "./awk.y"
  1943. { want_assign = FALSE; ;
  1944.     break;}
  1945. case 116:
  1946. #line 713 "./awk.y"
  1947. { yyval.nodeval = node(yyvsp[-3].nodeval, yyvsp[-2].nodetypeval, yyvsp[0].nodeval); ;
  1948.     break;}
  1949. case 117:
  1950. #line 715 "./awk.y"
  1951. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_and, yyvsp[0].nodeval); ;
  1952.     break;}
  1953. case 118:
  1954. #line 717 "./awk.y"
  1955. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_or, yyvsp[0].nodeval); ;
  1956.     break;}
  1957. case 119:
  1958. #line 719 "./awk.y"
  1959. {
  1960.           if (do_lint && ! io_allowed && yyvsp[0].nodeval == NULL)
  1961.             warning("non-redirected getline undefined inside BEGIN or END action");
  1962.           yyval.nodeval = node(yyvsp[-1].nodeval, Node_K_getline, yyvsp[0].nodeval);
  1963.         ;
  1964.     break;}
  1965. case 120:
  1966. #line 725 "./awk.y"
  1967. { yyval.nodeval = yyvsp[0].nodeval; ;
  1968.     break;}
  1969. case 121:
  1970. #line 727 "./awk.y"
  1971. { yyval.nodeval = node((NODE *) NULL, Node_nomatch, yyvsp[0].nodeval); ;
  1972.     break;}
  1973. case 122:
  1974. #line 729 "./awk.y"
  1975. { yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, mk_rexp(yyvsp[0].nodeval)); ;
  1976.     break;}
  1977. case 123:
  1978. #line 731 "./awk.y"
  1979. { yyval.nodeval = node(variable(yyvsp[0].sval, CAN_FREE, Node_var_array), Node_in_array, yyvsp[-2].nodeval); ;
  1980.     break;}
  1981. case 124:
  1982. #line 733 "./awk.y"
  1983. { yyval.nodeval = node(yyvsp[-2].nodeval, yyvsp[-1].nodetypeval, yyvsp[0].nodeval); ;
  1984.     break;}
  1985. case 125:
  1986. #line 735 "./awk.y"
  1987. { yyval.nodeval = node(yyvsp[-4].nodeval, Node_cond_exp, node(yyvsp[-2].nodeval, Node_if_branches, yyvsp[0].nodeval));;
  1988.     break;}
  1989. case 126:
  1990. #line 737 "./awk.y"
  1991. { yyval.nodeval = yyvsp[0].nodeval; ;
  1992.     break;}
  1993. case 127:
  1994. #line 739 "./awk.y"
  1995. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_concat, yyvsp[0].nodeval); ;
  1996.     break;}
  1997. case 129:
  1998. #line 746 "./awk.y"
  1999. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_exp, yyvsp[0].nodeval); ;
  2000.     break;}
  2001. case 130:
  2002. #line 748 "./awk.y"
  2003. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_times, yyvsp[0].nodeval); ;
  2004.     break;}
  2005. case 131:
  2006. #line 750 "./awk.y"
  2007. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_quotient, yyvsp[0].nodeval); ;
  2008.     break;}
  2009. case 132:
  2010. #line 752 "./awk.y"
  2011. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_mod, yyvsp[0].nodeval); ;
  2012.     break;}
  2013. case 133:
  2014. #line 754 "./awk.y"
  2015. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_plus, yyvsp[0].nodeval); ;
  2016.     break;}
  2017. case 134:
  2018. #line 756 "./awk.y"
  2019. { yyval.nodeval = node(yyvsp[-2].nodeval, Node_minus, yyvsp[0].nodeval); ;
  2020.     break;}
  2021. case 135:
  2022. #line 758 "./awk.y"
  2023. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_postincrement, (NODE *) NULL); ;
  2024.     break;}
  2025. case 136:
  2026. #line 760 "./awk.y"
  2027. { yyval.nodeval = node(yyvsp[-1].nodeval, Node_postdecrement, (NODE *) NULL); ;
  2028.     break;}
  2029. case 137:
  2030. #line 765 "./awk.y"
  2031. { yyval.nodeval = node(yyvsp[0].nodeval, Node_not, (NODE *) NULL); ;
  2032.     break;}
  2033. case 138:
  2034. #line 767 "./awk.y"
  2035. { yyval.nodeval = yyvsp[-1].nodeval; ;
  2036.     break;}
  2037. case 139:
  2038. #line 770 "./awk.y"
  2039. { yyval.nodeval = snode(yyvsp[-1].nodeval, Node_builtin, (int) yyvsp[-3].lval); ;
  2040.     break;}
  2041. case 140:
  2042. #line 772 "./awk.y"
  2043. { yyval.nodeval = snode(yyvsp[-1].nodeval, Node_builtin, (int) yyvsp[-3].lval); ;
  2044.     break;}
  2045. case 141:
  2046. #line 774 "./awk.y"
  2047. {
  2048.         if (do_lint)
  2049.             warning("call of `length' without parentheses is not portable");
  2050.         yyval.nodeval = snode((NODE *) NULL, Node_builtin, (int) yyvsp[0].lval);
  2051.         if (do_posix)
  2052.             warning("call of `length' without parentheses is deprecated by POSIX");
  2053.       ;
  2054.     break;}
  2055. case 142:
  2056. #line 782 "./awk.y"
  2057. {
  2058.         yyval.nodeval = node(yyvsp[-1].nodeval, Node_func_call, make_string(yyvsp[-3].sval, strlen(yyvsp[-3].sval)));
  2059.         func_use(yyvsp[-3].sval, FUNC_USE);
  2060.         param_sanity(yyvsp[-1].nodeval);
  2061.         free(yyvsp[-3].sval);
  2062.       ;
  2063.     break;}
  2064. case 144:
  2065. #line 790 "./awk.y"
  2066. { yyval.nodeval = node(yyvsp[0].nodeval, Node_preincrement, (NODE *) NULL); ;
  2067.     break;}
  2068. case 145:
  2069. #line 792 "./awk.y"
  2070. { yyval.nodeval = node(yyvsp[0].nodeval, Node_predecrement, (NODE *) NULL); ;
  2071.     break;}
  2072. case 146:
  2073. #line 794 "./awk.y"
  2074. { yyval.nodeval = yyvsp[0].nodeval; ;
  2075.     break;}
  2076. case 147:
  2077. #line 796 "./awk.y"
  2078. { yyval.nodeval = yyvsp[0].nodeval; ;
  2079.     break;}
  2080. case 148:
  2081. #line 799 "./awk.y"
  2082. {
  2083.           if (yyvsp[0].nodeval->type == Node_val) {
  2084.             yyvsp[0].nodeval->numbr = -(force_number(yyvsp[0].nodeval));
  2085.             yyval.nodeval = yyvsp[0].nodeval;
  2086.           } else
  2087.             yyval.nodeval = node(yyvsp[0].nodeval, Node_unary_minus, (NODE *) NULL);
  2088.         ;
  2089.     break;}
  2090. case 149:
  2091. #line 807 "./awk.y"
  2092. {
  2093.           /*
  2094.            * was: $$ = $2
  2095.            * POSIX semantics: force a conversion to numeric type
  2096.            */
  2097.           yyval.nodeval = node (make_number(0.0), Node_plus, yyvsp[0].nodeval);
  2098.         ;
  2099.     break;}
  2100. case 150:
  2101. #line 818 "./awk.y"
  2102. { yyval.nodeval = NULL; ;
  2103.     break;}
  2104. case 151:
  2105. #line 820 "./awk.y"
  2106. { yyval.nodeval = yyvsp[0].nodeval; ;
  2107.     break;}
  2108. case 152:
  2109. #line 825 "./awk.y"
  2110. { yyval.nodeval = variable(yyvsp[0].sval, CAN_FREE, Node_var); ;
  2111.     break;}
  2112. case 153:
  2113. #line 827 "./awk.y"
  2114. {
  2115.         if (yyvsp[-1].nodeval->rnode == NULL) {
  2116.             yyval.nodeval = node(variable(yyvsp[-3].sval, CAN_FREE, Node_var_array), Node_subscript, yyvsp[-1].nodeval->lnode);
  2117.             freenode(yyvsp[-1].nodeval);
  2118.         } else
  2119.             yyval.nodeval = node(variable(yyvsp[-3].sval, CAN_FREE, Node_var_array), Node_subscript, yyvsp[-1].nodeval);
  2120.         ;
  2121.     break;}
  2122. case 154:
  2123. #line 835 "./awk.y"
  2124. { yyval.nodeval = node(yyvsp[0].nodeval, Node_field_spec, (NODE *) NULL); ;
  2125.     break;}
  2126. case 156:
  2127. #line 843 "./awk.y"
  2128. { yyerrok; ;
  2129.     break;}
  2130. case 157:
  2131. #line 847 "./awk.y"
  2132. { yyerrok; ;
  2133.     break;}
  2134. case 160:
  2135. #line 856 "./awk.y"
  2136. { yyerrok; want_assign = FALSE; ;
  2137.     break;}
  2138. case 161:
  2139. #line 859 "./awk.y"
  2140. { yyerrok; ;
  2141.     break;}
  2142. }
  2143.    /* the action file gets copied in in place of this dollarsign */
  2144. #line 465 "/usr/local/lib/bison.simple"
  2145.  
  2146.   yyvsp -= yylen;
  2147.   yyssp -= yylen;
  2148. #ifdef YYLSP_NEEDED
  2149.   yylsp -= yylen;
  2150. #endif
  2151.  
  2152. #if YYDEBUG != 0
  2153.   if (yydebug)
  2154.     {
  2155.       short *ssp1 = yyss - 1;
  2156.       fprintf (stderr, "state stack now");
  2157.       while (ssp1 != yyssp)
  2158.     fprintf (stderr, " %d", *++ssp1);
  2159.       fprintf (stderr, "\n");
  2160.     }
  2161. #endif
  2162.  
  2163.   *++yyvsp = yyval;
  2164.  
  2165. #ifdef YYLSP_NEEDED
  2166.   yylsp++;
  2167.   if (yylen == 0)
  2168.     {
  2169.       yylsp->first_line = yylloc.first_line;
  2170.       yylsp->first_column = yylloc.first_column;
  2171.       yylsp->last_line = (yylsp-1)->last_line;
  2172.       yylsp->last_column = (yylsp-1)->last_column;
  2173.       yylsp->text = 0;
  2174.     }
  2175.   else
  2176.     {
  2177.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  2178.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  2179.     }
  2180. #endif
  2181.  
  2182.   /* Now "shift" the result of the reduction.
  2183.      Determine what state that goes to,
  2184.      based on the state we popped back to
  2185.      and the rule number reduced by.  */
  2186.  
  2187.   yyn = yyr1[yyn];
  2188.  
  2189.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  2190.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  2191.     yystate = yytable[yystate];
  2192.   else
  2193.     yystate = yydefgoto[yyn - YYNTBASE];
  2194.  
  2195.   goto yynewstate;
  2196.  
  2197. yyerrlab:   /* here on detecting error */
  2198.  
  2199.   if (! yyerrstatus)
  2200.     /* If not already recovering from an error, report this error.  */
  2201.     {
  2202.       ++yynerrs;
  2203.  
  2204. #ifdef YYERROR_VERBOSE
  2205.       yyn = yypact[yystate];
  2206.  
  2207.       if (yyn > YYFLAG && yyn < YYLAST)
  2208.     {
  2209.       int size = 0;
  2210.       char *msg;
  2211.       int x, count;
  2212.  
  2213.       count = 0;
  2214.       /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
  2215.       for (x = (yyn < 0 ? -yyn : 0);
  2216.            x < (sizeof(yytname) / sizeof(char *)); x++)
  2217.         if (yycheck[x + yyn] == x)
  2218.           size += strlen(yytname[x]) + 15, count++;
  2219.       msg = (char *) malloc(size + 15);
  2220.       if (msg != 0)
  2221.         {
  2222.           strcpy(msg, "parse error");
  2223.  
  2224.           if (count < 5)
  2225.         {
  2226.           count = 0;
  2227.           for (x = (yyn < 0 ? -yyn : 0);
  2228.                x < (sizeof(yytname) / sizeof(char *)); x++)
  2229.             if (yycheck[x + yyn] == x)
  2230.               {
  2231.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  2232.             strcat(msg, yytname[x]);
  2233.             strcat(msg, "'");
  2234.             count++;
  2235.               }
  2236.         }
  2237.           yyerror(msg);
  2238.           free(msg);
  2239.         }
  2240.       else
  2241.         yyerror ("parse error; also virtual memory exceeded");
  2242.     }
  2243.       else
  2244. #endif /* YYERROR_VERBOSE */
  2245.     yyerror("parse error");
  2246.     }
  2247.  
  2248.   goto yyerrlab1;
  2249. yyerrlab1:   /* here on error raised explicitly by an action */
  2250.  
  2251.   if (yyerrstatus == 3)
  2252.     {
  2253.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  2254.  
  2255.       /* return failure if at end of input */
  2256.       if (yychar == YYEOF)
  2257.     YYABORT;
  2258.  
  2259. #if YYDEBUG != 0
  2260.       if (yydebug)
  2261.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  2262. #endif
  2263.  
  2264.       yychar = YYEMPTY;
  2265.     }
  2266.  
  2267.   /* Else will try to reuse lookahead token
  2268.      after shifting the error token.  */
  2269.  
  2270.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  2271.  
  2272.   goto yyerrhandle;
  2273.  
  2274. yyerrdefault:  /* current state does not do anything special for the error token. */
  2275.  
  2276. #if 0
  2277.   /* This is wrong; only states that explicitly want error tokens
  2278.      should shift them.  */
  2279.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  2280.   if (yyn) goto yydefault;
  2281. #endif
  2282.  
  2283. yyerrpop:   /* pop the current state because it cannot handle the error token */
  2284.  
  2285.   if (yyssp == yyss) YYABORT;
  2286.   yyvsp--;
  2287.   yystate = *--yyssp;
  2288. #ifdef YYLSP_NEEDED
  2289.   yylsp--;
  2290. #endif
  2291.  
  2292. #if YYDEBUG != 0
  2293.   if (yydebug)
  2294.     {
  2295.       short *ssp1 = yyss - 1;
  2296.       fprintf (stderr, "Error: state stack now");
  2297.       while (ssp1 != yyssp)
  2298.     fprintf (stderr, " %d", *++ssp1);
  2299.       fprintf (stderr, "\n");
  2300.     }
  2301. #endif
  2302.  
  2303. yyerrhandle:
  2304.  
  2305.   yyn = yypact[yystate];
  2306.   if (yyn == YYFLAG)
  2307.     goto yyerrdefault;
  2308.  
  2309.   yyn += YYTERROR;
  2310.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  2311.     goto yyerrdefault;
  2312.  
  2313.   yyn = yytable[yyn];
  2314.   if (yyn < 0)
  2315.     {
  2316.       if (yyn == YYFLAG)
  2317.     goto yyerrpop;
  2318.       yyn = -yyn;
  2319.       goto yyreduce;
  2320.     }
  2321.   else if (yyn == 0)
  2322.     goto yyerrpop;
  2323.  
  2324.   if (yyn == YYFINAL)
  2325.     YYACCEPT;
  2326.  
  2327. #if YYDEBUG != 0
  2328.   if (yydebug)
  2329.     fprintf(stderr, "Shifting error token, ");
  2330. #endif
  2331.  
  2332.   *++yyvsp = yylval;
  2333. #ifdef YYLSP_NEEDED
  2334.   *++yylsp = yylloc;
  2335. #endif
  2336.  
  2337.   yystate = yyn;
  2338.   goto yynewstate;
  2339. }
  2340. #line 862 "./awk.y"
  2341.  
  2342.  
  2343. struct token {
  2344.     const char *operator;        /* text to match */
  2345.     NODETYPE value;        /* node type */
  2346.     int class;        /* lexical class */
  2347.     unsigned flags;        /* # of args. allowed and compatability */
  2348. #    define    ARGS    0xFF    /* 0, 1, 2, 3 args allowed (any combination */
  2349. #    define    A(n)    (1<<(n))
  2350. #    define    VERSION    0xFF00    /* old awk is zero */
  2351. #    define    NOT_OLD        0x0100    /* feature not in old awk */
  2352. #    define    NOT_POSIX    0x0200    /* feature not in POSIX */
  2353. #    define    GAWKX        0x0400    /* gawk extension */
  2354. #    define    RESX        0x0800    /* Bell Labs Research extension */
  2355.     NODE *(*ptr)();        /* function that implements this keyword */
  2356. };
  2357.  
  2358. extern NODE
  2359.     *do_exp(),    *do_getline(),    *do_index(),    *do_length(),
  2360.     *do_sqrt(),    *do_log(),    *do_sprintf(),    *do_substr(),
  2361.     *do_split(),    *do_system(),    *do_int(),    *do_close(),
  2362.     *do_atan2(),    *do_sin(),    *do_cos(),    *do_rand(),
  2363.     *do_srand(),    *do_match(),    *do_tolower(),    *do_toupper(),
  2364.     *do_sub(),    *do_gsub(),    *do_strftime(),    *do_systime(),
  2365.     *do_fflush();
  2366.  
  2367. /* Tokentab is sorted ascii ascending order, so it can be binary searched. */
  2368.  
  2369. static struct token tokentab[] = {
  2370. {"BEGIN",    Node_illegal,     LEX_BEGIN,    0,        0},
  2371. {"END",        Node_illegal,     LEX_END,    0,        0},
  2372. {"atan2",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2),    do_atan2},
  2373. {"break",    Node_K_break,     LEX_BREAK,    0,        0},
  2374. {"close",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_close},
  2375. {"continue",    Node_K_continue, LEX_CONTINUE,    0,        0},
  2376. {"cos",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_cos},
  2377. {"delete",    Node_K_delete,     LEX_DELETE,    NOT_OLD,    0},
  2378. {"do",        Node_K_do,     LEX_DO,    NOT_OLD,    0},
  2379. {"else",    Node_illegal,     LEX_ELSE,    0,        0},
  2380. {"exit",    Node_K_exit,     LEX_EXIT,    0,        0},
  2381. {"exp",        Node_builtin,     LEX_BUILTIN,    A(1),        do_exp},
  2382. {"fflush",    Node_builtin,     LEX_BUILTIN,    RESX|A(0)|A(1), do_fflush},
  2383. {"for",        Node_K_for,     LEX_FOR,    0,        0},
  2384. {"func",    Node_K_function, LEX_FUNCTION,    NOT_POSIX|NOT_OLD,    0},
  2385. {"function",    Node_K_function, LEX_FUNCTION,    NOT_OLD,    0},
  2386. {"gensub",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(3)|A(4), do_gensub},
  2387. {"getline",    Node_K_getline,     LEX_GETLINE,    NOT_OLD,    0},
  2388. {"gsub",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2)|A(3), do_gsub},
  2389. {"if",        Node_K_if,     LEX_IF,    0,        0},
  2390. {"in",        Node_illegal,     LEX_IN,    0,        0},
  2391. {"index",    Node_builtin,     LEX_BUILTIN,    A(2),        do_index},
  2392. {"int",        Node_builtin,     LEX_BUILTIN,    A(1),        do_int},
  2393. {"length",    Node_builtin,     LEX_LENGTH,    A(0)|A(1),    do_length},
  2394. {"log",        Node_builtin,     LEX_BUILTIN,    A(1),        do_log},
  2395. {"match",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2),    do_match},
  2396. {"next",    Node_K_next,     LEX_NEXT,    0,        0},
  2397. {"nextfile",    Node_K_nextfile, LEX_NEXTFILE,    GAWKX,        0},
  2398. {"print",    Node_K_print,     LEX_PRINT,    0,        0},
  2399. {"printf",    Node_K_printf,     LEX_PRINTF,    0,        0},
  2400. {"rand",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(0),    do_rand},
  2401. {"return",    Node_K_return,     LEX_RETURN,    NOT_OLD,    0},
  2402. {"sin",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_sin},
  2403. {"split",    Node_builtin,     LEX_BUILTIN,    A(2)|A(3),    do_split},
  2404. {"sprintf",    Node_builtin,     LEX_BUILTIN,    0,        do_sprintf},
  2405. {"sqrt",    Node_builtin,     LEX_BUILTIN,    A(1),        do_sqrt},
  2406. {"srand",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(0)|A(1), do_srand},
  2407. {"strftime",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(0)|A(1)|A(2), do_strftime},
  2408. {"sub",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2)|A(3), do_sub},
  2409. {"substr",    Node_builtin,     LEX_BUILTIN,    A(2)|A(3),    do_substr},
  2410. {"system",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_system},
  2411. {"systime",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(0),    do_systime},
  2412. {"tolower",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_tolower},
  2413. {"toupper",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_toupper},
  2414. {"while",    Node_K_while,     LEX_WHILE,    0,        0},
  2415. };
  2416.  
  2417. /* yyerror --- print a syntax error message, show where */
  2418.  
  2419. #if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
  2420. static void
  2421. yyerror(const char *m, ...)
  2422. #else
  2423. /* VARARGS0 */
  2424. static void
  2425. yyerror(va_alist)
  2426. va_dcl
  2427. #endif
  2428. {
  2429.     va_list args;
  2430.     const char *mesg = NULL;
  2431.     register char *bp, *cp;
  2432.     char *scan;
  2433.     char buf[120];
  2434.     static char end_of_file_line[] = "(END OF FILE)";
  2435.  
  2436.     errcount++;
  2437.     /* Find the current line in the input file */
  2438.     if (lexptr && lexeme) {
  2439.         if (thisline == NULL) {
  2440.             cp = lexeme;
  2441.             if (*cp == '\n') {
  2442.                 cp--;
  2443.                 mesg = "unexpected newline";
  2444.             }
  2445.             for (; cp != lexptr_begin && *cp != '\n'; --cp)
  2446.                 continue;
  2447.             if (*cp == '\n')
  2448.                 cp++;
  2449.             thisline = cp;
  2450.         }
  2451.         /* NL isn't guaranteed */
  2452.         bp = lexeme;
  2453.         while (bp < lexend && *bp && *bp != '\n')
  2454.             bp++;
  2455.     } else {
  2456.         thisline = end_of_file_line;
  2457.         bp = thisline + strlen(thisline);
  2458.     }
  2459.     msg("%.*s", (int) (bp - thisline), thisline);
  2460.     bp = buf;
  2461.     cp = buf + sizeof(buf) - 24;    /* 24 more than longest msg. input */
  2462.     if (lexptr != NULL) {
  2463.         scan = thisline;
  2464.         while (bp < cp && scan < lexeme)
  2465.             if (*scan++ == '\t')
  2466.                 *bp++ = '\t';
  2467.             else
  2468.                 *bp++ = ' ';
  2469.         *bp++ = '^';
  2470.         *bp++ = ' ';
  2471.     }
  2472. #if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
  2473.     va_start(args, m);
  2474.     if (mesg == NULL)
  2475.         mesg = m;
  2476. #else
  2477.     va_start(args);
  2478.     if (mesg == NULL)
  2479.         mesg = va_arg(args, char *);
  2480. #endif
  2481.     strcpy(bp, mesg);
  2482.     err("", buf, args);
  2483.     va_end(args);
  2484.     exit(2);
  2485. }
  2486.  
  2487. /* get_src_buf --- read the next buffer of source program */
  2488.  
  2489. static char *
  2490. get_src_buf()
  2491. {
  2492.     static int samefile = FALSE;
  2493.     static int nextfile = 0;
  2494.     static char *buf = NULL;
  2495.     static int fd;
  2496.     int n;
  2497.     register char *scan;
  2498.     static int len = 0;
  2499.     static int did_newline = FALSE;
  2500.     struct stat sbuf;
  2501.  
  2502. #    define    SLOP    128    /* enough space to hold most source lines */
  2503.  
  2504. again:
  2505.     if (nextfile > numfiles)
  2506.         return NULL;
  2507.  
  2508.     if (srcfiles[nextfile].stype == CMDLINE) {
  2509.         if (len == 0) {
  2510.             len = strlen(srcfiles[nextfile].val);
  2511.             if (len == 0) {
  2512.                 /*
  2513.                  * Yet Another Special case:
  2514.                  *    gawk '' /path/name
  2515.                  * Sigh.
  2516.                  */
  2517.                 static int warned = FALSE;
  2518.  
  2519.                 if (do_lint && ! warned) {
  2520.                     warned = TRUE;
  2521.                     warning("empty program text on command line");
  2522.                 }
  2523.                 ++nextfile;
  2524.                 goto again;
  2525.             }
  2526.             sourceline = 1;
  2527.             lexptr = lexptr_begin = srcfiles[nextfile].val;
  2528.             lexend = lexptr + len;
  2529.         } else if (! did_newline && *(lexptr-1) != '\n') {
  2530.             /*
  2531.              * The following goop is to ensure that the source
  2532.              * ends with a newline and that the entire current
  2533.              * line is available for error messages.
  2534.              */
  2535.             int offset;
  2536.  
  2537.             did_newline = TRUE;
  2538.             offset = lexptr - lexeme;
  2539.             for (scan = lexeme; scan > lexptr_begin; scan--)
  2540.                 if (*scan == '\n') {
  2541.                     scan++;
  2542.                     break;
  2543.                 }
  2544.             len = lexptr - scan;
  2545.             emalloc(buf, char *, len+1, "get_src_buf");
  2546.             memcpy(buf, scan, len);
  2547.             thisline = buf;
  2548.             lexptr = buf + len;
  2549.             *lexptr = '\n';
  2550.             lexeme = lexptr - offset;
  2551.             lexptr_begin = buf;
  2552.             lexend = lexptr + 1;
  2553.         } else {
  2554.             len = 0;
  2555.             lexeme = lexptr = lexptr_begin = NULL;
  2556.         }
  2557.         if (lexptr == NULL && ++nextfile <= numfiles)
  2558.             goto again;
  2559.         return lexptr;
  2560.     }
  2561.     if (! samefile) {
  2562.         source = srcfiles[nextfile].val;
  2563.         if (source == NULL) {
  2564.             if (buf != NULL) {
  2565.                 free(buf);
  2566.                 buf = NULL;
  2567.             }
  2568.             len = 0;
  2569.             return lexeme = lexptr = lexptr_begin = NULL;
  2570.         }
  2571.         fd = pathopen(source);
  2572.         if (fd <= INVALID_HANDLE) {
  2573.             char *in;
  2574.  
  2575.             /* suppress file name and line no. in error mesg */
  2576.             in = source;
  2577.             source = NULL;
  2578.             fatal("can't open source file \"%s\" for reading (%s)",
  2579.                 in, strerror(errno));
  2580.         }
  2581.         len = optimal_bufsize(fd, & sbuf);
  2582.         if (sbuf.st_size == 0) {
  2583.             static int warned = FALSE;
  2584.  
  2585.             if (do_lint && ! warned) {
  2586.                 warned = TRUE;
  2587.                 warning("source file `%s' is empty", source);
  2588.             }
  2589.             close(fd);
  2590.             ++nextfile;
  2591.             goto again;
  2592.         }
  2593.         if (buf != NULL)
  2594.             free(buf);
  2595.         emalloc(buf, char *, len + SLOP, "get_src_buf");
  2596.         lexptr_begin = buf + SLOP;
  2597.         samefile = TRUE;
  2598.         sourceline = 1;
  2599.     } else {
  2600.         /*
  2601.          * Here, we retain the current source line (up to length SLOP)
  2602.          * in the beginning of the buffer that was overallocated above
  2603.          */
  2604.         int offset;
  2605.         int linelen;
  2606.  
  2607.         offset = lexptr - lexeme;
  2608.         for (scan = lexeme; scan > lexptr_begin; scan--)
  2609.             if (*scan == '\n') {
  2610.                 scan++;
  2611.                 break;
  2612.             }
  2613.         linelen = lexptr - scan;
  2614.         if (linelen > SLOP)
  2615.             linelen = SLOP;
  2616.         thisline = buf + SLOP - linelen;
  2617.         memcpy(thisline, scan, linelen);
  2618.         lexeme = buf + SLOP - offset;
  2619.         lexptr_begin = thisline;
  2620.     }
  2621.     n = read(fd, buf + SLOP, len);
  2622.     if (n == -1)
  2623.         fatal("can't read sourcefile \"%s\" (%s)",
  2624.             source, strerror(errno));
  2625.     if (n == 0) {
  2626.         close(fd);
  2627.         samefile = FALSE;
  2628.         nextfile++;
  2629.         if (lexeme)
  2630.             *lexeme = '\0';
  2631.         len = 0;
  2632.         goto again;
  2633.     }
  2634.     lexptr = buf + SLOP;
  2635.     lexend = lexptr + n;
  2636.     return buf;
  2637. }
  2638.  
  2639. /* tokadd --- add a character to the token buffer */
  2640.  
  2641. #define    tokadd(x) (*tok++ = (x), tok == tokend ? tokexpand() : tok)
  2642.  
  2643. /* tokexpand --- grow the token buffer */
  2644.  
  2645. char *
  2646. tokexpand()
  2647. {
  2648.     static int toksize = 60;
  2649.     int tokoffset;
  2650.  
  2651.     tokoffset = tok - tokstart;
  2652.     toksize *= 2;
  2653.     if (tokstart != NULL)
  2654.         erealloc(tokstart, char *, toksize, "tokexpand");
  2655.     else
  2656.         emalloc(tokstart, char *, toksize, "tokexpand");
  2657.     tokend = tokstart + toksize;
  2658.     tok = tokstart + tokoffset;
  2659.     return tok;
  2660. }
  2661.  
  2662. /* nextc --- get the next input character */
  2663.  
  2664. #if DEBUG
  2665. int
  2666. nextc()
  2667. {
  2668.     int c;
  2669.  
  2670.     if (lexptr && lexptr < lexend)
  2671.         c = *lexptr++;
  2672.     else if (get_src_buf())
  2673.         c = *lexptr++;
  2674.     else
  2675.         c = EOF;
  2676.  
  2677.     return c;
  2678. }
  2679. #else
  2680. #define    nextc()    ((lexptr && lexptr < lexend) ? \
  2681.             *lexptr++ : \
  2682.             (get_src_buf() ? *lexptr++ : EOF) \
  2683.         )
  2684. #endif
  2685.  
  2686. /* pushback --- push a character back on the input */
  2687.  
  2688. #define pushback() (lexptr && lexptr > lexptr_begin ? lexptr-- : lexptr)
  2689.  
  2690. /* allow_newline --- allow newline after &&, ||, ? and : */
  2691.  
  2692. static void
  2693. allow_newline()
  2694. {
  2695.     int c;
  2696.  
  2697.     for (;;) {
  2698.         c = nextc();
  2699.         if (c == EOF)
  2700.             break;
  2701.         if (c == '#') {
  2702.             while ((c = nextc()) != '\n' && c != EOF)
  2703.                 continue;
  2704.             if (c == EOF)
  2705.                 break;
  2706.         }
  2707.         if (c == '\n')
  2708.             sourceline++;
  2709.         if (! isspace(c)) {
  2710.             pushback();
  2711.             break;
  2712.         }
  2713.     }
  2714. }
  2715.  
  2716. /* yylex --- Read the input and turn it into tokens. */
  2717.  
  2718. static int
  2719. yylex()
  2720. {
  2721.     register int c, c1;
  2722.     int seen_e = FALSE;        /* These are for numbers */
  2723.     int seen_point = FALSE;
  2724.     int esc_seen;        /* for literal strings */
  2725.     int low, mid, high;
  2726.     static int did_newline = FALSE;
  2727.     char *tokkey;
  2728.     static int lasttok = 0, eof_warned = FALSE;
  2729.  
  2730.     if (nextc() == EOF) {
  2731.         if (lasttok != NEWLINE) {
  2732.             lasttok = NEWLINE;
  2733.             if (do_lint && ! eof_warned) {
  2734.                 warning("source file does not end in newline");
  2735.                 eof_warned = TRUE;
  2736.             }
  2737.             return NEWLINE;    /* fake it */
  2738.         }
  2739.         return 0;
  2740.     }
  2741.     pushback();
  2742. #ifdef OS2
  2743.     /*
  2744.      * added for OS/2's extproc feature of cmd.exe
  2745.      * (like #! in BSD sh)
  2746.      */
  2747.     if (strncasecmp(lexptr, "extproc ", 8) == 0) {
  2748.         while (*lexptr && *lexptr != '\n')
  2749.             lexptr++;
  2750.     }
  2751. #endif
  2752.     lexeme = lexptr;
  2753.     thisline = NULL;
  2754.     if (want_regexp) {
  2755.         int in_brack = 0;    /* count brackets, [[:alnum:]] allowed */
  2756.         /*
  2757.          * Counting brackets is non-trivial. [[] is ok,
  2758.          * and so is [\]], with a point being that /[/]/ as a regexp
  2759.          * constant has to work.
  2760.          *
  2761.          * Do not count [ or ] if either one is preceded by a \.
  2762.          * A `[' should be counted if
  2763.          *  a) it is the first one so far (in_brack == 0)
  2764.          *  b) it is the `[' in `[:'
  2765.          * A ']' should be counted if not preceded by a \, since
  2766.          * it is either closing `:]' or just a plain list.
  2767.          * According to POSIX, []] is how you put a ] into a set.
  2768.          * Try to handle that too.
  2769.          *
  2770.          * The code for \ handles \[ and \].
  2771.          */
  2772.  
  2773.         want_regexp = FALSE;
  2774.         tok = tokstart;
  2775.         for (;;) {
  2776.             c = nextc();
  2777.             switch (c) {
  2778.             case '[':
  2779.                 /* one day check for `.' and `=' too */
  2780.                 if ((c1 = nextc()) == ':' || in_brack == 0)
  2781.                     in_brack++;
  2782.                 pushback();
  2783.                 break;
  2784.             case ']':
  2785.                 if (tokstart[0] == '['
  2786.                     && (tok == tokstart + 1
  2787.                     || (tok == tokstart + 2
  2788.                         && tokstart[1] == '^')))
  2789.                     /* do nothing */;
  2790.                 else
  2791.                     in_brack--;
  2792.                 break;
  2793.             case '\\':
  2794.                 if ((c = nextc()) == EOF) {
  2795.                     yyerror("unterminated regexp ends with \\ at end of file");
  2796.                     return lasttok = REGEXP; /* kludge */
  2797.                 } else if (c == '\n') {
  2798.                     sourceline++;
  2799.                     continue;
  2800.                 } else {
  2801.                     tokadd('\\');
  2802.                     tokadd(c);
  2803.                     continue;
  2804.                 }
  2805.                 break;
  2806.             case '/':    /* end of the regexp */
  2807.                 if (in_brack > 0)
  2808.                     break;
  2809.  
  2810.                 pushback();
  2811.                 tokadd('\0');
  2812.                 yylval.sval = tokstart;
  2813.                 return lasttok = REGEXP;
  2814.             case '\n':
  2815.                 pushback();
  2816.                 yyerror("unterminated regexp");
  2817.                 return lasttok = REGEXP;    /* kludge */
  2818.             case EOF:
  2819.                 yyerror("unterminated regexp at end of file");
  2820.                 return lasttok = REGEXP;    /* kludge */
  2821.             }
  2822.             tokadd(c);
  2823.         }
  2824.     }
  2825. retry:
  2826.     while ((c = nextc()) == ' ' || c == '\t')
  2827.         continue;
  2828.  
  2829.     lexeme = lexptr ? lexptr - 1 : lexptr;
  2830.     thisline = NULL;
  2831.     tok = tokstart;
  2832.     yylval.nodetypeval = Node_illegal;
  2833.  
  2834.     switch (c) {
  2835.     case EOF:
  2836.         if (lasttok != NEWLINE) {
  2837.             lasttok = NEWLINE;
  2838.             if (do_lint && ! eof_warned) {
  2839.                 warning("source file does not end in newline");
  2840.                 eof_warned = TRUE;
  2841.             }
  2842.             return NEWLINE;    /* fake it */
  2843.         }
  2844.         return 0;
  2845.  
  2846.     case '\n':
  2847.         sourceline++;
  2848.         return lasttok = NEWLINE;
  2849.  
  2850.     case '#':        /* it's a comment */
  2851.         while ((c = nextc()) != '\n') {
  2852.             if (c == EOF) {
  2853.                 if (lasttok != NEWLINE) {
  2854.                     lasttok = NEWLINE;
  2855.                     if (do_lint && ! eof_warned) {
  2856.                         warning(
  2857.                 "source file does not end in newline");
  2858.                         eof_warned = TRUE;
  2859.                     }
  2860.                     return NEWLINE;    /* fake it */
  2861.                 }
  2862.                 return 0;
  2863.             }
  2864.         }
  2865.         sourceline++;
  2866.         return lasttok = NEWLINE;
  2867.  
  2868.     case '\\':
  2869. #ifdef RELAXED_CONTINUATION
  2870.         /*
  2871.          * This code puports to allow comments and/or whitespace
  2872.          * after the `\' at the end of a line used for continuation.
  2873.          * Use it at your own risk. We think it's a bad idea, which
  2874.          * is why it's not on by default.
  2875.          */
  2876.         if (! do_traditional) {
  2877.             /* strip trailing white-space and/or comment */
  2878.             while ((c = nextc()) == ' ' || c == '\t')
  2879.                 continue;
  2880.             if (c == '#') {
  2881.                 if (do_lint)
  2882.                     warning(
  2883.         "use of `\\ #...' line continuation is not portable");
  2884.                 while ((c = nextc()) != '\n')
  2885.                     if (c == EOF)
  2886.                         break;
  2887.             }
  2888.             pushback();
  2889.         }
  2890. #endif /* RELAXED_CONTINUATION */
  2891.         if (nextc() == '\n') {
  2892.             sourceline++;
  2893.             goto retry;
  2894.         } else
  2895.             yyerror("backslash not last character on line");
  2896.         break;
  2897.  
  2898.     case '$':
  2899.         want_assign = TRUE;
  2900.         return lasttok = '$';
  2901.  
  2902.     case ':':
  2903.     case '?':
  2904.         allow_newline();
  2905.         /* fall through */
  2906.     case ')':
  2907.     case ']':
  2908.     case '(':    
  2909.     case '[':
  2910.     case ';':
  2911.     case '{':
  2912.     case ',':
  2913.         return lasttok = c;
  2914.  
  2915.     case '*':
  2916.         if ((c = nextc()) == '=') {
  2917.             yylval.nodetypeval = Node_assign_times;
  2918.             return lasttok = ASSIGNOP;
  2919.         } else if (do_posix) {
  2920.             pushback();
  2921.             return lasttok = '*';
  2922.         } else if (c == '*') {
  2923.             /* make ** and **= aliases for ^ and ^= */
  2924.             static int did_warn_op = FALSE, did_warn_assgn = FALSE;
  2925.  
  2926.             if (nextc() == '=') {
  2927.                 if (do_lint && ! did_warn_assgn) {
  2928.                     did_warn_assgn = TRUE;
  2929.                     warning("**= is not allowed by POSIX");
  2930.                     warning("operator `**=' is not supported in old awk");
  2931.                 }
  2932.                 yylval.nodetypeval = Node_assign_exp;
  2933.                 return ASSIGNOP;
  2934.             } else {
  2935.                 pushback();
  2936.                 if (do_lint && ! did_warn_op) {
  2937.                     did_warn_op = TRUE;
  2938.                     warning("** is not allowed by POSIX");
  2939.                     warning("operator `**' is not supported in old awk");
  2940.                 }
  2941.                 return lasttok = '^';
  2942.             }
  2943.         }
  2944.         pushback();
  2945.         return lasttok = '*';
  2946.  
  2947.     case '/':
  2948.         if (want_assign) {
  2949.             if (nextc() == '=') {
  2950.                 yylval.nodetypeval = Node_assign_quotient;
  2951.                 return lasttok = ASSIGNOP;
  2952.             }
  2953.             pushback();
  2954.         }
  2955.         return lasttok = '/';
  2956.  
  2957.     case '%':
  2958.         if (nextc() == '=') {
  2959.             yylval.nodetypeval = Node_assign_mod;
  2960.             return lasttok = ASSIGNOP;
  2961.         }
  2962.         pushback();
  2963.         return lasttok = '%';
  2964.  
  2965.     case '^':
  2966.     {
  2967.         static int did_warn_op = FALSE, did_warn_assgn = FALSE;
  2968.  
  2969.         if (nextc() == '=') {
  2970.             if (do_lint && ! did_warn_assgn) {
  2971.                 did_warn_assgn = TRUE;
  2972.                 warning("operator `^=' is not supported in old awk");
  2973.             }
  2974.             yylval.nodetypeval = Node_assign_exp;
  2975.             return lasttok = ASSIGNOP;
  2976.         }
  2977.         pushback();
  2978.         if (do_lint && ! did_warn_op) {
  2979.             did_warn_op = TRUE;
  2980.             warning("operator `^' is not supported in old awk");
  2981.         }
  2982.         return lasttok = '^';
  2983.     }
  2984.  
  2985.     case '+':
  2986.         if ((c = nextc()) == '=') {
  2987.             yylval.nodetypeval = Node_assign_plus;
  2988.             return lasttok = ASSIGNOP;
  2989.         }
  2990.         if (c == '+')
  2991.             return lasttok = INCREMENT;
  2992.         pushback();
  2993.         return lasttok = '+';
  2994.  
  2995.     case '!':
  2996.         if ((c = nextc()) == '=') {
  2997.             yylval.nodetypeval = Node_notequal;
  2998.             return lasttok = RELOP;
  2999.         }
  3000.         if (c == '~') {
  3001.             yylval.nodetypeval = Node_nomatch;
  3002.             want_assign = FALSE;
  3003.             return lasttok = MATCHOP;
  3004.         }
  3005.         pushback();
  3006.         return lasttok = '!';
  3007.  
  3008.     case '<':
  3009.         if (nextc() == '=') {
  3010.             yylval.nodetypeval = Node_leq;
  3011.             return lasttok = RELOP;
  3012.         }
  3013.         yylval.nodetypeval = Node_less;
  3014.         pushback();
  3015.         return lasttok = '<';
  3016.  
  3017.     case '=':
  3018.         if (nextc() == '=') {
  3019.             yylval.nodetypeval = Node_equal;
  3020.             return lasttok = RELOP;
  3021.         }
  3022.         yylval.nodetypeval = Node_assign;
  3023.         pushback();
  3024.         return lasttok = ASSIGNOP;
  3025.  
  3026.     case '>':
  3027.         if ((c = nextc()) == '=') {
  3028.             yylval.nodetypeval = Node_geq;
  3029.             return lasttok = RELOP;
  3030.         } else if (c == '>') {
  3031.             yylval.nodetypeval = Node_redirect_append;
  3032.             return lasttok = APPEND_OP;
  3033.         }
  3034.         yylval.nodetypeval = Node_greater;
  3035.         pushback();
  3036.         return lasttok = '>';
  3037.  
  3038.     case '~':
  3039.         yylval.nodetypeval = Node_match;
  3040.         want_assign = FALSE;
  3041.         return lasttok = MATCHOP;
  3042.  
  3043.     case '}':
  3044.         /*
  3045.          * Added did newline stuff.  Easier than
  3046.          * hacking the grammar.
  3047.          */
  3048.         if (did_newline) {
  3049.             did_newline = FALSE;
  3050.             return lasttok = c;
  3051.         }
  3052.         did_newline++;
  3053.         --lexptr;    /* pick up } next time */
  3054.         return lasttok = NEWLINE;
  3055.  
  3056.     case '"':
  3057.         esc_seen = FALSE;
  3058.         while ((c = nextc()) != '"') {
  3059.             if (c == '\n') {
  3060.                 pushback();
  3061.                 yyerror("unterminated string");
  3062.             }
  3063.             if (c == '\\') {
  3064.                 c = nextc();
  3065.                 if (c == '\n') {
  3066.                     sourceline++;
  3067.                     continue;
  3068.                 }
  3069.                 esc_seen = TRUE;
  3070.                 tokadd('\\');
  3071.             }
  3072.             if (c == EOF) {
  3073.                 pushback();
  3074.                 yyerror("unterminated string");
  3075.             }
  3076.             tokadd(c);
  3077.         }
  3078.         yylval.nodeval = make_str_node(tokstart,
  3079.                     tok - tokstart, esc_seen ? SCAN : 0);
  3080.         yylval.nodeval->flags |= PERM;
  3081.         return lasttok = YSTRING;
  3082.  
  3083.     case '-':
  3084.         if ((c = nextc()) == '=') {
  3085.             yylval.nodetypeval = Node_assign_minus;
  3086.             return lasttok = ASSIGNOP;
  3087.         }
  3088.         if (c == '-')
  3089.             return lasttok = DECREMENT;
  3090.         pushback();
  3091.         return lasttok = '-';
  3092.  
  3093.     case '.':
  3094.         c = nextc();
  3095.         pushback();
  3096.         if (! isdigit(c))
  3097.             return lasttok = '.';
  3098.         else
  3099.             c = '.';
  3100.         /* FALL THROUGH */
  3101.     case '0':
  3102.     case '1':
  3103.     case '2':
  3104.     case '3':
  3105.     case '4':
  3106.     case '5':
  3107.     case '6':
  3108.     case '7':
  3109.     case '8':
  3110.     case '9':
  3111.         /* It's a number */
  3112.         for (;;) {
  3113.             int gotnumber = FALSE;
  3114.  
  3115.             tokadd(c);
  3116.             switch (c) {
  3117.             case '.':
  3118.                 if (seen_point) {
  3119.                     gotnumber = TRUE;
  3120.                     break;
  3121.                 }
  3122.                 seen_point = TRUE;
  3123.                 break;
  3124.             case 'e':
  3125.             case 'E':
  3126.                 if (seen_e) {
  3127.                     gotnumber = TRUE;
  3128.                     break;
  3129.                 }
  3130.                 seen_e = TRUE;
  3131.                 if ((c = nextc()) == '-' || c == '+')
  3132.                     tokadd(c);
  3133.                 else
  3134.                     pushback();
  3135.                 break;
  3136.             case '0':
  3137.             case '1':
  3138.             case '2':
  3139.             case '3':
  3140.             case '4':
  3141.             case '5':
  3142.             case '6':
  3143.             case '7':
  3144.             case '8':
  3145.             case '9':
  3146.                 break;
  3147.             default:
  3148.                 gotnumber = TRUE;
  3149.             }
  3150.             if (gotnumber)
  3151.                 break;
  3152.             c = nextc();
  3153.         }
  3154.         if (c != EOF)
  3155.             pushback();
  3156.         else if (do_lint && ! eof_warned) {
  3157.             warning("source file does not end in newline");
  3158.             eof_warned = TRUE;
  3159.         }
  3160.         tokadd('\0');
  3161.         yylval.nodeval = make_number(atof(tokstart));
  3162.         yylval.nodeval->flags |= PERM;
  3163.         return lasttok = YNUMBER;
  3164.  
  3165.     case '&':
  3166.         if ((c = nextc()) == '&') {
  3167.             yylval.nodetypeval = Node_and;
  3168.             allow_newline();
  3169.             want_assign = FALSE;
  3170.             return lasttok = LEX_AND;
  3171.         }
  3172.         pushback();
  3173.         return lasttok = '&';
  3174.  
  3175.     case '|':
  3176.         if ((c = nextc()) == '|') {
  3177.             yylval.nodetypeval = Node_or;
  3178.             allow_newline();
  3179.             want_assign = FALSE;
  3180.             return lasttok = LEX_OR;
  3181.         }
  3182.         pushback();
  3183.         return lasttok = '|';
  3184.     }
  3185.  
  3186.     if (c != '_' && ! isalpha(c))
  3187.         yyerror("Invalid char '%c' in expression\n", c);
  3188.  
  3189.     /* it's some type of name-type-thing.  Find its length. */
  3190.     tok = tokstart;
  3191.     while (is_identchar(c)) {
  3192.         tokadd(c);
  3193.         c = nextc();
  3194.     }
  3195.     tokadd('\0');
  3196.     emalloc(tokkey, char *, tok - tokstart, "yylex");
  3197.     memcpy(tokkey, tokstart, tok - tokstart);
  3198.     if (c != EOF)
  3199.         pushback();
  3200.     else if (do_lint && ! eof_warned) {
  3201.         warning("source file does not end in newline");
  3202.         eof_warned = TRUE;
  3203.     }
  3204.  
  3205.     /* See if it is a special token. */
  3206.     low = 0;
  3207.     high = (sizeof(tokentab) / sizeof(tokentab[0])) - 1;
  3208.     while (low <= high) {
  3209.         int i;
  3210.  
  3211.         mid = (low + high) / 2;
  3212.         c = *tokstart - tokentab[mid].operator[0];
  3213.         i = c ? c : strcmp(tokstart, tokentab[mid].operator);
  3214.  
  3215.         if (i < 0)        /* token < mid */
  3216.             high = mid - 1;
  3217.         else if (i > 0)        /* token > mid */
  3218.             low = mid + 1;
  3219.         else {
  3220.             if (do_lint) {
  3221.                 if (tokentab[mid].flags & GAWKX)
  3222.                     warning("%s() is a gawk extension",
  3223.                         tokentab[mid].operator);
  3224.                 if (tokentab[mid].flags & RESX)
  3225.                     warning("%s() is a Bell Labs extension",
  3226.                         tokentab[mid].operator);
  3227.                 if (tokentab[mid].flags & NOT_POSIX)
  3228.                     warning("POSIX does not allow %s",
  3229.                         tokentab[mid].operator);
  3230.             }
  3231.             if (do_lint_old && (tokentab[mid].flags & NOT_OLD))
  3232.                 warning("%s is not supported in old awk",
  3233.                         tokentab[mid].operator);
  3234.             if ((do_traditional && (tokentab[mid].flags & GAWKX))
  3235.                 || (do_posix && (tokentab[mid].flags & NOT_POSIX)))
  3236.                 break;
  3237.             if (tokentab[mid].class == LEX_BUILTIN
  3238.                 || tokentab[mid].class == LEX_LENGTH
  3239.                )
  3240.                 yylval.lval = mid;
  3241.             else
  3242.                 yylval.nodetypeval = tokentab[mid].value;
  3243.  
  3244.             free(tokkey);
  3245.             return lasttok = tokentab[mid].class;
  3246.         }
  3247.     }
  3248.  
  3249.     yylval.sval = tokkey;
  3250.     if (*lexptr == '(')
  3251.         return lasttok = FUNC_CALL;
  3252.     else {
  3253.         want_assign = TRUE;
  3254.         return lasttok = NAME;
  3255.     }
  3256. }
  3257.  
  3258. /* node_common --- common code for allocating a new node */
  3259.  
  3260. static NODE *
  3261. node_common(op)
  3262. NODETYPE op;
  3263. {
  3264.     register NODE *r;
  3265.  
  3266.     getnode(r);
  3267.     r->type = op;
  3268.     r->flags = MALLOC;
  3269.     /* if lookahead is NL, lineno is 1 too high */
  3270.     if (lexeme && *lexeme == '\n')
  3271.         r->source_line = sourceline - 1;
  3272.     else
  3273.         r->source_line = sourceline;
  3274.     r->source_file = source;
  3275.     return r;
  3276. }
  3277.  
  3278. /* node --- allocates a node with defined lnode and rnode. */
  3279.  
  3280. NODE *
  3281. node(left, op, right)
  3282. NODE *left, *right;
  3283. NODETYPE op;
  3284. {
  3285.     register NODE *r;
  3286.  
  3287.     r = node_common(op);
  3288.     r->lnode = left;
  3289.     r->rnode = right;
  3290.     return r;
  3291. }
  3292.  
  3293. /* snode ---    allocate a node with defined subnode and proc for builtin
  3294.         functions. Checks for arg. count and supplies defaults where
  3295.         possible. */
  3296.  
  3297. static NODE *
  3298. snode(subn, op, idx)
  3299. NODETYPE op;
  3300. int idx;
  3301. NODE *subn;
  3302. {
  3303.     register NODE *r;
  3304.     register NODE *n;
  3305.     int nexp = 0;
  3306.     int args_allowed;
  3307.  
  3308.     r = node_common(op);
  3309.  
  3310.     /* traverse expression list to see how many args. given */
  3311.     for (n = subn; n != NULL; n = n->rnode) {
  3312.         nexp++;
  3313.         if (nexp > 3)
  3314.             break;
  3315.     }
  3316.  
  3317.     /* check against how many args. are allowed for this builtin */
  3318.     args_allowed = tokentab[idx].flags & ARGS;
  3319.     if (args_allowed && (args_allowed & A(nexp)) == 0)
  3320.         fatal("%s() cannot have %d argument%c",
  3321.             tokentab[idx].operator, nexp, nexp == 1 ? ' ' : 's');
  3322.  
  3323.     r->proc = tokentab[idx].ptr;
  3324.  
  3325.     /* special case processing for a few builtins */
  3326.     if (nexp == 0 && r->proc == do_length) {
  3327.         subn = node(node(make_number(0.0), Node_field_spec, (NODE *) NULL),
  3328.                     Node_expression_list,
  3329.                 (NODE *) NULL);
  3330.     } else if (r->proc == do_match) {
  3331.         if (subn->rnode->lnode->type != Node_regex)
  3332.             subn->rnode->lnode = mk_rexp(subn->rnode->lnode);
  3333.     } else if (r->proc == do_sub || r->proc == do_gsub) {
  3334.         if (subn->lnode->type != Node_regex)
  3335.             subn->lnode = mk_rexp(subn->lnode);
  3336.         if (nexp == 2)
  3337.             append_right(subn, node(node(make_number(0.0),
  3338.                              Node_field_spec,
  3339.                              (NODE *) NULL),
  3340.                             Node_expression_list,
  3341.                         (NODE *) NULL));
  3342.         else if (do_lint && subn->rnode->rnode->lnode->type == Node_val)
  3343.             warning("string literal as last arg of substitute");
  3344.     } else if (r->proc == do_gensub) {
  3345.         if (subn->lnode->type != Node_regex)
  3346.             subn->lnode = mk_rexp(subn->lnode);
  3347.         if (nexp == 3)
  3348.             append_right(subn, node(node(make_number(0.0),
  3349.                              Node_field_spec,
  3350.                              (NODE *) NULL),
  3351.                             Node_expression_list,
  3352.                         (NODE *) NULL));
  3353.     } else if (r->proc == do_split) {
  3354.         if (nexp == 2)
  3355.             append_right(subn,
  3356.                 node(FS_node, Node_expression_list, (NODE *) NULL));
  3357.         n = subn->rnode->rnode->lnode;
  3358.         if (n->type != Node_regex)
  3359.             subn->rnode->rnode->lnode = mk_rexp(n);
  3360.         if (nexp == 2)
  3361.             subn->rnode->rnode->lnode->re_flags |= FS_DFLT;
  3362.     }
  3363.  
  3364.     r->subnode = subn;
  3365.     return r;
  3366. }
  3367.  
  3368. /*
  3369.  * mkrangenode:
  3370.  * This allocates a Node_line_range node with defined condpair and
  3371.  * zeroes the trigger word to avoid the temptation of assuming that calling
  3372.  * 'node( foo, Node_line_range, 0)' will properly initialize 'triggered'. 
  3373.  * Otherwise like node().
  3374.  */
  3375.  
  3376. static NODE *
  3377. mkrangenode(cpair)
  3378. NODE *cpair;
  3379. {
  3380.     register NODE *r;
  3381.  
  3382.     getnode(r);
  3383.     r->type = Node_line_range;
  3384.     r->condpair = cpair;
  3385.     r->triggered = FALSE;
  3386.     return r;
  3387. }
  3388.  
  3389. /* make_for_loop --- build a for loop */
  3390.  
  3391. static NODE *
  3392. make_for_loop(init, cond, incr)
  3393. NODE *init, *cond, *incr;
  3394. {
  3395.     register FOR_LOOP_HEADER *r;
  3396.     NODE *n;
  3397.  
  3398.     emalloc(r, FOR_LOOP_HEADER *, sizeof(FOR_LOOP_HEADER), "make_for_loop");
  3399.     getnode(n);
  3400.     n->type = Node_illegal;
  3401.     r->init = init;
  3402.     r->cond = cond;
  3403.     r->incr = incr;
  3404.     n->sub.nodep.r.hd = r;
  3405.     return n;
  3406. }
  3407.  
  3408. /* dup_parms --- return TRUE if there are duplicate parameters */
  3409.  
  3410. static int
  3411. dup_parms(func)
  3412. NODE *func;
  3413. {
  3414.     register NODE *np;
  3415.     char *fname, **names;
  3416.     int count, i, j, dups;
  3417.     NODE *params;
  3418.  
  3419.     fname = func->param;
  3420.     count = func->param_cnt;
  3421.     params = func->rnode;
  3422.  
  3423.     if (count == 0)        /* no args, no problem */
  3424.         return FALSE;
  3425.  
  3426.     emalloc(names, char **, count * sizeof(char *), "dup_parms");
  3427.  
  3428.     i = 0;
  3429.     for (np = params; np != NULL; np = np->rnode)
  3430.         names[i++] = np->param;
  3431.  
  3432.     dups = 0;
  3433.     for (i = 1; i < count; i++) {
  3434.         for (j = 0; j < i; j++) {
  3435.             if (strcmp(names[i], names[j]) == 0) {
  3436.                 dups++;
  3437.                 error(
  3438.     "function `%s': parameter #%d, `%s', duplicates parameter #%d",
  3439.                     fname, i+1, names[j], j+1);
  3440.             }
  3441.         }
  3442.     }
  3443.  
  3444.     free(names);
  3445.     return (dups > 0 ? TRUE : FALSE);
  3446. }
  3447.  
  3448. /*
  3449.  * install:
  3450.  * Install a name in the symbol table, even if it is already there.
  3451.  * Caller must check against redefinition if that is desired. 
  3452.  */
  3453.  
  3454. NODE *
  3455. install(name, value)
  3456. char *name;
  3457. NODE *value;
  3458. {
  3459.     register NODE *hp;
  3460.     register size_t len;
  3461.     register int bucket;
  3462.  
  3463.     len = strlen(name);
  3464.     bucket = hash(name, len, (unsigned long) HASHSIZE);
  3465.     getnode(hp);
  3466.     hp->type = Node_hashnode;
  3467.     hp->hnext = variables[bucket];
  3468.     variables[bucket] = hp;
  3469.     hp->hlength = len;
  3470.     hp->hvalue = value;
  3471.     hp->hname = name;
  3472.     hp->hvalue->vname = name;
  3473.     return hp->hvalue;
  3474. }
  3475.  
  3476. /* lookup --- find the most recent hash node for name installed by install */
  3477.  
  3478. NODE *
  3479. lookup(name)
  3480. const char *name;
  3481. {
  3482.     register NODE *bucket;
  3483.     register size_t len;
  3484.  
  3485.     len = strlen(name);
  3486.     for (bucket = variables[hash(name, len, (unsigned long) HASHSIZE)];
  3487.             bucket != NULL; bucket = bucket->hnext)
  3488.         if (bucket->hlength == len && STREQN(bucket->hname, name, len))
  3489.             return bucket->hvalue;
  3490.  
  3491.     return NULL;
  3492. }
  3493.  
  3494. /*
  3495.  * append_right:
  3496.  * Add new to the rightmost branch of LIST.  This uses n^2 time, so we make
  3497.  * a simple attempt at optimizing it.
  3498.  */
  3499.  
  3500. static NODE *
  3501. append_right(list, new)
  3502. NODE *list, *new;
  3503. {
  3504.     register NODE *oldlist;
  3505.     static NODE *savefront = NULL, *savetail = NULL;
  3506.  
  3507.     oldlist = list;
  3508.     if (savefront == oldlist) {
  3509.         savetail = savetail->rnode = new;
  3510.         return oldlist;
  3511.     } else
  3512.         savefront = oldlist;
  3513.     while (list->rnode != NULL)
  3514.         list = list->rnode;
  3515.     savetail = list->rnode = new;
  3516.     return oldlist;
  3517. }
  3518.  
  3519. /*
  3520.  * func_install:
  3521.  * check if name is already installed;  if so, it had better have Null value,
  3522.  * in which case def is added as the value. Otherwise, install name with def
  3523.  * as value. 
  3524.  */
  3525.  
  3526. static void
  3527. func_install(params, def)
  3528. NODE *params;
  3529. NODE *def;
  3530. {
  3531.     NODE *r;
  3532.  
  3533.     pop_params(params->rnode);
  3534.     pop_var(params, FALSE);
  3535.     r = lookup(params->param);
  3536.     if (r != NULL) {
  3537.         fatal("function name `%s' previously defined", params->param);
  3538.     } else
  3539.         (void) install(params->param, node(params, Node_func, def));
  3540.  
  3541.     func_use(params->param, FUNC_DEFINE);
  3542. }
  3543.  
  3544. /* pop_var --- remove a variable from the symbol table */
  3545.  
  3546. static void
  3547. pop_var(np, freeit)
  3548. NODE *np;
  3549. int freeit;
  3550. {
  3551.     register NODE *bucket, **save;
  3552.     register size_t len;
  3553.     char *name;
  3554.  
  3555.     name = np->param;
  3556.     len = strlen(name);
  3557.     save = &(variables[hash(name, len, (unsigned long) HASHSIZE)]);
  3558.     for (bucket = *save; bucket != NULL; bucket = bucket->hnext) {
  3559.         if (len == bucket->hlength && STREQN(bucket->hname, name, len)) {
  3560.             *save = bucket->hnext;
  3561.             freenode(bucket);
  3562.             if (freeit)
  3563.                 free(np->param);
  3564.             return;
  3565.         }
  3566.         save = &(bucket->hnext);
  3567.     }
  3568. }
  3569.  
  3570. /* pop_params --- remove list of function parameters from symbol table */
  3571.  
  3572. /*
  3573.  * pop parameters out of the symbol table. do this in reverse order to
  3574.  * avoid reading freed memory if there were duplicated parameters.
  3575.  */
  3576. static void
  3577. pop_params(params)
  3578. NODE *params;
  3579. {
  3580.     if (params == NULL)
  3581.         return;
  3582.     pop_params(params->rnode);
  3583.     pop_var(params, TRUE);
  3584. }
  3585.  
  3586. /* make_param --- make NAME into a function parameter */
  3587.  
  3588. static NODE *
  3589. make_param(name)
  3590. char *name;
  3591. {
  3592.     NODE *r;
  3593.  
  3594.     getnode(r);
  3595.     r->type = Node_param_list;
  3596.     r->rnode = NULL;
  3597.     r->param = name;
  3598.     r->param_cnt = param_counter++;
  3599.     return (install(name, r));
  3600. }
  3601.  
  3602. static struct fdesc {
  3603.     char *name;
  3604.     short used;
  3605.     short defined;
  3606.     struct fdesc *next;
  3607. } *ftable[HASHSIZE];
  3608.  
  3609. /* func_use --- track uses and definitions of functions */
  3610.  
  3611. static void
  3612. func_use(name, how)
  3613. char *name;
  3614. enum defref how;
  3615. {
  3616.     struct fdesc *fp;
  3617.     int len;
  3618.     int ind;
  3619.  
  3620.     len = strlen(name);
  3621.     ind = hash(name, len, HASHSIZE);
  3622.  
  3623.     for (fp = ftable[ind]; fp != NULL; fp = fp->next) {
  3624.         if (strcmp(fp->name, name) == 0) {
  3625.             if (how == FUNC_DEFINE)
  3626.                 fp->defined++;
  3627.             else
  3628.                 fp->used++;
  3629.             return;
  3630.         }
  3631.     }
  3632.  
  3633.     /* not in the table, fall through to allocate a new one */
  3634.  
  3635.     emalloc(fp, struct fdesc *, sizeof(struct fdesc), "func_use");
  3636.     memset(fp, '\0', sizeof(struct fdesc));
  3637.     emalloc(fp->name, char *, len + 1, "func_use");
  3638.     strcpy(fp->name, name);
  3639.     if (how == FUNC_DEFINE)
  3640.         fp->defined++;
  3641.     else
  3642.         fp->used++;
  3643.     fp->next = ftable[ind];
  3644.     ftable[ind] = fp;
  3645. }
  3646.  
  3647. /* check_funcs --- verify functions that are called but not defined */
  3648.  
  3649. static void
  3650. check_funcs()
  3651. {
  3652.     struct fdesc *fp, *next;
  3653.     int i;
  3654.  
  3655.     for (i = 0; i < HASHSIZE; i++) {
  3656.         for (fp = ftable[i]; fp != NULL; fp = fp->next) {
  3657. #ifdef REALLYMEAN
  3658.             /* making this the default breaks old code. sigh. */
  3659.             if (fp->defined == 0) {
  3660.                 error(
  3661.         "function `%s' called but never defined", fp->name);
  3662.                 errcount++;
  3663.             }
  3664. #else
  3665.             if (do_lint && fp->defined == 0)
  3666.                 warning(
  3667.         "function `%s' called but never defined", fp->name);
  3668. #endif
  3669.             if (do_lint && fp->used == 0) {
  3670.                 warning("function `%s' defined but never called",
  3671.                     fp->name);
  3672.             }
  3673.         }
  3674.     }
  3675.  
  3676.     /* now let's free all the memory */
  3677.     for (i = 0; i < HASHSIZE; i++) {
  3678.         for (fp = ftable[i]; fp != NULL; fp = next) {
  3679.             next = fp->next;
  3680.             free(fp->name);
  3681.             free(fp);
  3682.         }
  3683.     }
  3684. }
  3685.  
  3686. /* param_sanity --- look for parameters that are regexp constants */
  3687.  
  3688. static void
  3689. param_sanity(arglist)
  3690. NODE *arglist;
  3691. {
  3692.     NODE *argp, *arg;
  3693.     int i;
  3694.  
  3695.     for (i = 1, argp = arglist; argp != NULL; argp = argp->rnode, i++) {
  3696.         arg = argp->lnode;
  3697.         if (arg->type == Node_regex)
  3698.             warning("regexp constant for parameter #%d yields boolean value", i);
  3699.     }
  3700. }
  3701.  
  3702. /* variable --- make sure NAME is in the symbol table */
  3703.  
  3704. NODE *
  3705. variable(name, can_free, type)
  3706. char *name;
  3707. int can_free;
  3708. NODETYPE type;
  3709. {
  3710.     register NODE *r;
  3711.     static int env_loaded = FALSE;
  3712.  
  3713.     if (! env_loaded && STREQ(name, "ENVIRON")) {
  3714.         load_environ();
  3715.         env_loaded = TRUE;
  3716.     }
  3717.     if ((r = lookup(name)) == NULL)
  3718.         r = install(name, node(Nnull_string, type, (NODE *) NULL));
  3719.     else if (can_free)
  3720.         free(name);
  3721.     return r;
  3722. }
  3723.  
  3724. /* mk_rexp --- make a regular expression constant */
  3725.  
  3726. static NODE *
  3727. mk_rexp(exp)
  3728. NODE *exp;
  3729. {
  3730.     NODE *n;
  3731.  
  3732.     if (exp->type == Node_regex)
  3733.         return exp;
  3734.  
  3735.     getnode(n);
  3736.     n->type = Node_regex;
  3737.     n->re_exp = exp;
  3738.     n->re_text = NULL;
  3739.     n->re_reg = NULL;
  3740.     n->re_flags = 0;
  3741.     n->re_cnt = 1;
  3742.     return n;
  3743. }
  3744.  
  3745. /* isnoeffect --- when used as a statement, has no side effects */
  3746.  
  3747. /*
  3748.  * To be completely general, we should recursively walk the parse
  3749.  * tree, to make sure that all the subexpressions also have no effect.
  3750.  * Instead, we just weaken the actual warning that's printed, up above
  3751.  * in the grammar.
  3752.  */
  3753.  
  3754. static int
  3755. isnoeffect(type)
  3756. NODETYPE type;
  3757. {
  3758.     switch (type) {
  3759.     case Node_times:
  3760.     case Node_quotient:
  3761.     case Node_mod:
  3762.     case Node_plus:
  3763.     case Node_minus:
  3764.     case Node_subscript:
  3765.     case Node_concat:
  3766.     case Node_exp:
  3767.     case Node_unary_minus:
  3768.     case Node_field_spec:
  3769.     case Node_and:
  3770.     case Node_or:
  3771.     case Node_equal:
  3772.     case Node_notequal:
  3773.     case Node_less:
  3774.     case Node_greater:
  3775.     case Node_leq:
  3776.     case Node_geq:
  3777.     case Node_match:
  3778.     case Node_nomatch:
  3779.     case Node_not:
  3780.     case Node_val:
  3781.     case Node_in_array:
  3782.     case Node_NF:
  3783.     case Node_NR:
  3784.     case Node_FNR:
  3785.     case Node_FS:
  3786.     case Node_RS:
  3787.     case Node_FIELDWIDTHS:
  3788.     case Node_IGNORECASE:
  3789.     case Node_OFS:
  3790.     case Node_ORS:
  3791.     case Node_OFMT:
  3792.     case Node_CONVFMT:
  3793.         return TRUE;
  3794.     default:
  3795.         break;    /* keeps gcc -Wall happy */
  3796.     }
  3797.  
  3798.     return FALSE;
  3799. }
  3800.